GenericParameterPosition Propriété
TOC
Réduire la table des matières
Développer la table des matières
Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Propriété Type.GenericParameterPosition

 

Obtient la position du paramètre de type dans la liste des paramètres de type du type générique ou de la méthode qui a déclaré le paramètre, quand l'objet Type représente un paramètre de type d'un type générique ou une méthode générique.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public virtual int GenericParameterPosition { get; }

Valeur de propriété

Type: System.Int32

Position d'un paramètre de type dans la liste des paramètres de type du type générique ou de la méthode qui a défini le paramètre.La numérotation des positions commence à zéro.

Exception Condition
InvalidOperationException

Le type actuel ne représente pas un paramètre de type.Autrement dit, IsGenericParameter renvoie false.

Le GenericParameterPosition propriété retourne la position d'un paramètre de type dans la liste des paramètres de la définition de type générique ou la définition de méthode générique dans laquelle le paramètre de type a été défini à l'origine.Le DeclaringType et DeclaringMethod propriétés identifient la définition de type ou de méthode générique :

  • Si le DeclaringMethod propriété retourne un MethodInfo, qui MethodInfo représente une définition de méthode générique et en cours Type objet représente un paramètre de type de cette définition de méthode générique.

  • Si le DeclaringMethod propriété renvoie null, le DeclaringType retourne toujours un Type objet représentant une définition de type générique et en cours Type objet représente un paramètre de type de cette définition de type générique.

Pour fournir le contexte correct pour la valeur de la GenericParameterPosition propriété, il est nécessaire d'identifier le type générique ou une méthode, un paramètre de type appartient.Par exemple, considérez la valeur de retour de la méthode générique GetSomething dans le code suivant :

public class B<T, U> { }
public class A<V>
{
    public B<V, X> GetSomething<X>()
    {
        return new B<V, X>();
    }
}

Le type retourné par GetSomething dépend des arguments de type fournis à la classe A et GetSomething lui-même.Vous pouvez obtenir un MethodInfo de GetSomething, et depuis que vous pouvez obtenir le type de retour.Lorsque vous examinez les paramètres de type du type de retour, GenericParameterPosition retourne 0 pour les deux.La position de V est 0 car V est le premier paramètre de type dans la liste de paramètres de type pour la classe A.La position de X est 0 car X est le premier paramètre de type dans la liste de paramètres de type GetSomething.

System_CAPS_noteRemarque

Appelant le GenericParameterPosition propriété provoque une exception si actuel Type ne représente pas un paramètre de type.Lorsque vous examinez les arguments de type d'un type construit ouvert, utilisez la IsGenericParameter propriété pour indiquer à qui sont des paramètres de type et les types.Le IsGenericParameter propriété retourne true pour un paramètre de type, vous pouvez ensuite utiliser le GenericParameterPosition méthode pour obtenir sa position, utilisez le DeclaringMethod et DeclaringType pour déterminer la méthode générique ou type de définition qui le définit.

L'exemple suivant définit une classe générique avec deux paramètres de type et une deuxième classe générique qui dérive de la première classe.Classe de base de la classe dérivée a deux arguments de type : le premier est Int32, et le deuxième est un paramètre de type du type dérivé.L'exemple affiche des informations sur ces classes génériques, y compris les positions rapportées par le GenericParameterPosition propriété.

using System;
using System.Reflection;
using System.Collections.Generic;

// Define a base class with two type parameters.
public class Base<T, U> { }

// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
//   (1) Its generic type definition is Base<T, U>.
//   (2) It specifies int for the first type parameter.
//   (3) For the second type parameter, it uses the same type that is used
//       for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
public class Derived<V> : Base<int, V> { }

public class Test
{
    public static void Main()
    {
        Console.WriteLine(
            "\r\n--- Display a generic type and the open constructed");
        Console.WriteLine("    type from which it is derived.");

        // Create a Type object representing the generic type definition 
        // for the Derived type, by omitting the type argument. (For
        // types with multiple type parameters, supply the commas but
        // omit the type arguments.) 
        //
        Type derivedType = typeof(Derived<>);
        DisplayGenericTypeInfo(derivedType);

        // Display its open constructed base type.
        DisplayGenericTypeInfo(derivedType.BaseType);
    }

    private static void DisplayGenericTypeInfo(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);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}", 
            t.ContainsGenericParameters);

        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)
            {
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam.IsGenericParameter)
                {
                    Console.WriteLine(
                        "\t\t{0}  (unassigned - parameter position {1})",
                        tParam,
                        tParam.GenericParameterPosition);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Display a generic type and the open constructed
    type from which it is derived.

Derived`1[V]
        Is this a generic type definition? True
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                V  (unassigned - parameter position 0)

Base`2[System.Int32,V]
        Is this a generic type definition? False
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (2):
                System.Int32
                V  (unassigned - parameter position 0)
 */

Universal Windows Platform
Disponible depuis 4.5
.NET Framework
Disponible depuis 2.0
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher:
© 2016 Microsoft