Type.GetGenericArguments Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne un tableau d’objets Type qui représentent les arguments de type d’un type générique fermé ou les paramètres de type d’une définition de type générique.

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()

Retours

Type[]

Tableau d'objets Type qui représentent les arguments de type d'un type générique. Retourne un tableau vide si le type actuel n'est pas un type générique.

Exceptions

NotSupportedException

La méthode appelée n’est pas prise en charge dans la classe de base. Les classes dérivées doivent fournir une implémentation.

Exemples

L’exemple de code suivant utilise la GetGenericArguments méthode pour afficher les arguments de type d’un type construit et les paramètres de type de sa définition de type générique.

Cet exemple de code fait partie d’un exemple plus complet fourni pour la IsGenericTypeDefinition propriété. Consultez le plus grand exemple pour obtenir un exemple de sortie.

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

Remarques

Les éléments de tableau sont retournés dans l’ordre dans lequel ils apparaissent dans la liste d’arguments de type pour le type générique.

Si le type actuel est un type construit fermé (autrement dit, si la ContainsGenericParameters propriété retourne false ), le tableau retourné par la GetGenericArguments méthode contient les types qui ont été assignés aux paramètres de type générique de la définition de type générique.
Si le type actuel est une définition de type générique, le tableau contient les paramètres de type.
Si le type actuel est un type construit ouvert (autrement dit, la ContainsGenericParameters propriété retourne true ) dans laquelle des types spécifiques n’ont pas été assignés à tous les paramètres de type et les paramètres de type des types ou des méthodes génériques englobants, le tableau contient à la fois des types et des paramètres de type. Utilisez la IsGenericParameter propriété pour les distinguer. Pour une démonstration de ce scénario, consultez l’exemple de code pour la ContainsGenericParameters propriété.

Pour obtenir la liste des conditions indifférentes pour les termes utilisés dans la réflexion générique, consultez les notes sur la propriété IsGenericType.

S’applique à

Partager via