Type.GetGenericArguments Methode

Definition

Gibt ein Array von Type-Objekten zurück, die die Typargumente eines geschlossenen generischen Typs oder die Typparameter einer generischen Typdefinition darstellen.Returns an array of Type objects that represent the type arguments of a closed generic type or the type parameters of a generic type definition.

public:
 virtual cli::array <Type ^> ^ GetGenericArguments();
public virtual Type[] GetGenericArguments ();
abstract member GetGenericArguments : unit -> Type[]
override this.GetGenericArguments : unit -> Type[]
Public Overridable Function GetGenericArguments () As Type()

Gibt zurück

Type[]

Ein Array von Type-Objekten, die die Typargumente eines generischen Typs darstellen.An array of Type objects that represent the type arguments of a generic type. Gibt ein leeres Array zurück, wenn der aktuelle Typ kein generischer Typ ist.Returns an empty array if the current type is not a generic type.

Ausnahmen

Die aufgerufene Methode wird in der Basisklasse nicht unterstützt.The invoked method is not supported in the base class. Abgeleitete Klassen müssen eine Implementation angeben.Derived classes must provide an implementation.

Beispiele

Im folgenden Codebeispiel wird die GetGenericArguments -Methode verwendet, um die Typargumente eines konstruierten Typs und die Typparameter der generischen Typdefinition anzuzeigen.The following code example uses the GetGenericArguments method to display the type arguments of a constructed type and the type parameters of its generic type definition.

Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die IsGenericTypeDefinition -Eigenschaft bereitgestellt wird.This code example is part of a larger example provided for the IsGenericTypeDefinition property. Weitere Informationen finden Sie unter Beispielausgabe.See the larger example for sample output.

if ( t->IsGenericType )
{
   
   // If this is a generic type, display the type arguments.
   //
   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);
      
      // If this is a type parameter, display its
      // position.
      //
      if ( tParam->IsGenericParameter )
      {
         Console::WriteLine(
            L"\t\t{0}\t(unassigned - parameter position {1})",
            tParam, tParam->GenericParameterPosition );
      }
      else
      {
         Console::WriteLine( L"\t\t{0}", tParam );
      }
   }
}
if (t.IsGenericType)
{
    // If this is a generic type, display the type arguments.
    //
    Type[] typeArguments = t.GetGenericArguments();

    Console.WriteLine("\tList type arguments ({0}):", 
        typeArguments.Length);

    foreach (Type tParam in typeArguments)
    {
        // If this is a type parameter, display its
        // position.
        //
        if (tParam.IsGenericParameter)
        {
            Console.WriteLine("\t\t{0}\t(unassigned - parameter position {1})",
                tParam,
                tParam.GenericParameterPosition);
        }
        else
        {
            Console.WriteLine("\t\t{0}", tParam);
        }
    }
}
If t.IsGenericType Then
    ' If this is a generic type, display the type arguments.
    '
    Dim typeArguments As Type() = t.GetGenericArguments()
    
    Console.WriteLine(vbTab & "List type arguments (" _
        & typeArguments.Length & "):")
    
    For Each tParam As Type In typeArguments
        ' If this is a type parameter, display its position.
        '
        If tParam.IsGenericParameter Then
            Console.WriteLine(vbTab & vbTab & tParam.ToString() _
                & vbTab & "(unassigned - parameter position " _
                & tParam.GenericParameterPosition & ")")
        Else
            Console.WriteLine(vbTab & vbTab & tParam.ToString())
        End If
    Next tParam
End If

Hinweise

Die Array Elemente werden in der Reihenfolge zurückgegeben, in der Sie in der Liste der Typargumente für den generischen Typ angezeigt werden.The array elements are returned in the order in which they appear in the list of type arguments for the generic type.

  • Wenn es sich bei dem aktuellen Typ um einen geschlossenen konstruierten Typ handelt ContainsGenericParameters (d false. h., die-Eigenschaft GetGenericArguments gibt zurück), enthält das von der-Methode zurückgegebene Array die Typen, die den generischen Typparametern der generischen Typdefinition zugewiesen wurden. .If the current type is a closed constructed type (that is, the ContainsGenericParameters property returns false), the array returned by the GetGenericArguments method contains the types that have been assigned to the generic type parameters of the generic type definition.

  • Wenn der aktuelle Typ eine generische Typdefinition ist, enthält das Array die Typparameter.If the current type is a generic type definition, the array contains the type parameters.

  • Wenn der aktuelle Typ ein offener konstruierter Typ ist (d. h ContainsGenericParameters . die true-Eigenschaft gibt zurück), in der bestimmte Typen nicht allen Typparametern und Typparametern von einschließenden generischen Typen oder Methoden zugewiesen wurden, enthält das Array Beide Typen und Typparameter.If the current type is an open constructed type (that is, the ContainsGenericParameters property returns true) in which specific types have not been assigned to all of the type parameters and type parameters of enclosing generic types or methods, the array contains both types and type parameters. Verwenden Sie IsGenericParameter die-Eigenschaft, um sie voneinander zu informieren.Use the IsGenericParameter property to tell them apart. Eine Demonstration dieses Szenarios finden Sie im Codebeispiel für die ContainsGenericParameters -Eigenschaft.For a demonstration of this scenario, see the code example for the ContainsGenericParameters property.

Eine Liste der invarianten Bedingungen für Begriffe, für Begriffe, die für die Reflektion mit generischen Methoden verwendet werden, finden Sie in den Hinweisen zur Eigenschaft IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Gilt für:

Siehe auch