Type.GetGenericTypeDefinition Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Restituisce un oggetto Type che rappresenta una definizione di tipo generico da cui è possibile costruire il tipo generico corrente.
public:
abstract Type ^ GetGenericTypeDefinition();public:
virtual Type ^ GetGenericTypeDefinition();public abstract Type GetGenericTypeDefinition ();public virtual Type GetGenericTypeDefinition ();abstract member GetGenericTypeDefinition : unit -> Typeabstract member GetGenericTypeDefinition : unit -> Type
override this.GetGenericTypeDefinition : unit -> TypePublic MustOverride Function GetGenericTypeDefinition () As TypePublic Overridable Function GetGenericTypeDefinition () As TypeRestituisce
Oggetto Type che rappresenta un tipo generico da cui è possibile costruire il tipo corrente.
Eccezioni
Il tipo corrente non è generico. Ciò significa che IsGenericType restituisce false.
Il metodo richiamato non è supportato nella classe base. Le classi derivate devono fornire un'implementazione.
Esempio
Nell'esempio di codice seguente viene creata un'istanza di un tipo costruito utilizzando la normale creazione di un'istanza e quindi vengono utilizzati i metodi e per recuperare il tipo costruito e GetType la definizione di tipo GetGenericTypeDefinition generico. In questo esempio viene utilizzato il Dictionary<TKey,TValue> tipo generico . Il tipo costruito rappresenta un oggetto di oggetti con chiavi Dictionary<TKey,TValue> Test stringa.
using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;
public ref class Test
{
public:
static void Main()
{
Console::Write( L"\r\n--- Get the generic type that " );
Console::WriteLine( L"defines a constructed type." );
// Create a Dictionary of Test objects, using strings for the
// keys.
Dictionary< String^,Test^ >^ d = gcnew Dictionary< String^,Test^ >;
// Get a Type object representing the constructed type.
//
Type^ constructed = d->GetType();
DisplayTypeInfo( constructed );
Type^ myGeneric = constructed->GetGenericTypeDefinition();
DisplayTypeInfo( myGeneric );
}
private:
static void DisplayTypeInfo( Type^ t )
{
Console::WriteLine( L"\r\n{0}", t );
Console::WriteLine( L"\tIs this a generic type definition? {0}",
t->IsGenericTypeDefinition );
Console::WriteLine( L"\tIs it a generic type? {0}",
t->IsGenericType );
array<Type^>^typeArguments = t->GetGenericArguments();
Console::WriteLine( L"\tList type arguments ({0}):",
typeArguments->Length );
System::Collections::IEnumerator^ myEnum =
typeArguments->GetEnumerator();
while ( myEnum->MoveNext() )
{
Type^ tParam = safe_cast<Type^>(myEnum->Current);
Console::WriteLine( L"\t\t{0}", tParam );
}
}
};
int main()
{
Test::Main();
}
/* This example produces the following output:
--- Get the generic type that defines a constructed type.
System.Collections.Generic.Dictionary`2[System.String,Test]
Is this a generic type definition? False
Is it a generic type? True
List type arguments (2):
System.String
Test
System.Collections.Generic.Dictionary`2[TKey,TValue]
Is this a generic type definition? True
Is it a generic type? True
List type arguments (2):
TKey
TValue
*/
using System;
using System.Reflection;
using System.Collections.Generic;
public class Test
{
public static void Main()
{
Console.WriteLine("\r\n--- Get the generic type that defines a constructed type.");
// Create a Dictionary of Test objects, using strings for the
// keys.
Dictionary<string, Test> d = new Dictionary<string, Test>();
// Get a Type object representing the constructed type.
//
Type constructed = d.GetType();
DisplayTypeInfo(constructed);
Type generic = constructed.GetGenericTypeDefinition();
DisplayTypeInfo(generic);
}
private static void DisplayTypeInfo(Type t)
{
Console.WriteLine("\r\n{0}", t);
Console.WriteLine("\tIs this a generic type definition? {0}",
t.IsGenericTypeDefinition);
Console.WriteLine("\tIs it a generic type? {0}",
t.IsGenericType);
Type[] typeArguments = t.GetGenericArguments();
Console.WriteLine("\tList type arguments ({0}):", typeArguments.Length);
foreach (Type tParam in typeArguments)
{
Console.WriteLine("\t\t{0}", tParam);
}
}
}
/* This example produces the following output:
--- Get the generic type that defines a constructed type.
System.Collections.Generic.Dictionary`2[System.String,Test]
Is this a generic type definition? False
Is it a generic type? True
List type arguments (2):
System.String
Test
System.Collections.Generic.Dictionary`2[TKey,TValue]
Is this a generic type definition? True
Is it a generic type? True
List type arguments (2):
TKey
TValue
*/
Imports System.Reflection
Imports System.Collections.Generic
Public Class Test
Public Shared Sub Main()
Console.WriteLine(vbCrLf & "--- Get the generic type that defines a constructed type.")
' Create a Dictionary of Test objects, using strings for the
' keys.
Dim d As New Dictionary(Of String, Test)
' Get a Type object representing the constructed type.
'
Dim constructed As Type = d.GetType()
DisplayTypeInfo(constructed)
Dim generic As Type = constructed.GetGenericTypeDefinition()
DisplayTypeInfo(generic)
End Sub
Private Shared Sub DisplayTypeInfo(ByVal t As Type)
Console.WriteLine(vbCrLf & t.ToString())
Console.WriteLine(vbTab & "Is this a generic type definition? " _
& t.IsGenericTypeDefinition)
Console.WriteLine(vbTab & "Is it a generic type? " _
& t.IsGenericType)
Dim typeArguments As Type() = t.GetGenericArguments()
Console.WriteLine(vbTab & "List type arguments (" _
& typeArguments.Length & "):")
For Each tParam As Type In typeArguments
Console.WriteLine(vbTab & vbTab & tParam.ToString())
Next tParam
End Sub
End Class
' This example produces the following output:
'
'--- Get the generic type that defines a constructed type.
'
'System.Collections.Generic.Dictionary`2[System.String,Test]
' Is this a generic type definition? False
' Is it a generic type? True
' List type arguments (2):
' System.String
' Test
'
'System.Collections.Generic.Dictionary`2[TKey,TValue]
' Is this a generic type definition? True
' Is it a generic type? True
' List type arguments (2):
' TKey
' TValue
'
Commenti
Una definizione di tipo generico è un modello da cui è possibile costruire altri tipi. Ad esempio, dalla definizione di tipo generico (espressa nella sintassi G<T> G(Of T) C#, in Visual Basic o in generic <typename T> ref class G C++) è possibile costruire e creare un'istanza del G<int> tipo ( in G(Of Integer) Visual Basic). Dato un Type oggetto che rappresenta questo tipo costruito, il metodo restituisce la definizione di tipo GetGenericTypeDefinition generico.
Se vengono creati due tipi costruiti dalla stessa definizione di tipo generico, usando gli stessi argomenti di tipo, il metodo restituisce GetGenericTypeDefinition lo stesso oggetto per entrambi i Type tipi.
Se si chiama il GetGenericTypeDefinition metodo su un oggetto che rappresenta già una definizione di tipo Type generico, viene restituito l'oggetto Type corrente.
Importante
Una matrice di tipi generici non è di per sé generica. Nel codice C# A<int>[] v; o nel codice Visual Basic , il tipo di variabile non è Dim v() As A(Of Integer) v generico. Utilizzare IsGenericType per determinare se un tipo è generico prima di chiamare GetGenericTypeDefinition .
Per un elenco delle condizioni invariabili relative ai termini usati dal processo di reflection generico, vedere i commenti sulla proprietà IsGenericType.