MethodInfo.MakeGenericMethod(Type[]) Méthode

Définition

Espace de noms:

System.Reflection

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

MethodInfo.cs

Substitue les éléments d'un tableau de types aux paramètres de type de la définition de méthode générique actuelle et retourne un objet MethodInfo représentant la méthode construite résultante.

C#

public virtual System.Reflection.MethodInfo MakeGenericMethod(params Type[] typeArguments);

Paramètres

typeArguments

Type[]

Tableau de types à substituer aux paramètres de type de la définition de méthode générique actuelle.

Retours

MethodInfo

Objet MethodInfo qui représente la méthode construite formée en substituant les éléments de typeArguments aux les paramètres de type de la définition de méthode générique actuelle.

Exceptions

InvalidOperationException

Le MethodInfo actuel ne représente pas une définition de méthode générique. Autrement dit, IsGenericMethodDefinition retourne false.

ArgumentNullException

typeArguments a la valeur null.

-ou-

Tout élément de typeArguments est null.

ArgumentException

Le nombre d'éléments contenus dans typeArguments n'est pas identique au nombre de paramètres de type dans la définition de méthode générique actuelle.

- ou -

Un élément de typeArguments ne satisfait pas les contraintes spécifiées pour le paramètre de type correspondant de la définition de méthode générique actuelle.

NotSupportedException

Cette méthode n'est pas prise en charge.

Exemples

L’exemple de code suivant illustre les propriétés et méthodes de MethodInfo qui prennent en charge l’examen des méthodes génériques. L'exemple effectue les opérations suivantes :

• Définit une classe qui a une méthode générique.

• Crée un MethodInfo qui représente la méthode générique.

• Affiche les propriétés de la définition de méthode générique.

• Affecte des arguments de type aux paramètres de type de , MethodInfoet appelle la méthode générique construite résultante.

• Affiche les propriétés de la méthode générique construite.

• Récupère la définition de méthode générique de la méthode construite et la compare à la définition d’origine.

C#

using System;
using System.Reflection;

// Define a class with a generic method.
public class Example
{
    public static void Generic<T>(T toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }
}

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Examine a generic method.");

        // Create a Type object representing class Example, and
        // get a MethodInfo representing the generic method.
        //
        Type ex = typeof(Example);
        MethodInfo mi = ex.GetMethod("Generic");

        DisplayGenericMethodInfo(mi);

        // Assign the int type to the type parameter of the Example
        // method.
        //
        MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));

        DisplayGenericMethodInfo(miConstructed);

        // Invoke the method.
        object[] args = {42};
        miConstructed.Invoke(null, args);

        // Invoke the method normally.
        Example.Generic<int>(42);

        // Get the generic type definition from the closed method,
        // and show it's the same as the original definition.
        //
        MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
        Console.WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
    }

    private static void DisplayGenericMethodInfo(MethodInfo mi)
    {
        Console.WriteLine("\r\n{0}", mi);

        Console.WriteLine("\tIs this a generic method definition? {0}",
            mi.IsGenericMethodDefinition);

        Console.WriteLine("\tIs it a generic method? {0}",
            mi.IsGenericMethod);

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

        // If this is a generic method, display its type arguments.
        //
        if (mi.IsGenericMethod)
        {
            Type[] typeArguments = mi.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}  parameter position {1}" +
                        "\n\t\t   declaring method: {2}",
                        tParam,
                        tParam.GenericParameterPosition,
                        tParam.DeclaringMethod);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Examine a generic method.

Void Generic[T](T)
        Is this a generic method definition? True
        Is it a generic method? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                T  parameter position 0
                   declaring method: Void Generic[T](T)

Void Generic[Int32](Int32)
        Is this a generic method definition? False
        Is it a generic method? True
        Does it have unassigned generic parameters? False
        List type arguments (1):
                System.Int32

Here it is: 42

Here it is: 42

The definition is the same: True

 */

Remarques

La MakeGenericMethod méthode vous permet d’écrire du code qui affecte des types spécifiques aux paramètres de type d’une définition de méthode générique, créant ainsi un MethodInfo objet qui représente une méthode construite particulière. Si la ContainsGenericParameters propriété de cet MethodInfo objet retourne true, vous pouvez l’utiliser pour appeler la méthode ou pour créer un délégué pour appeler la méthode.

Les méthodes construites avec la MakeGenericMethod méthode peuvent être ouvertes, c’est-à-dire que certains de leurs arguments de type peuvent être des paramètres de type englobant des types génériques. Vous pouvez utiliser ces méthodes construites ouvertes lorsque vous générez des assemblys dynamiques. Par exemple, considérez le code C#, Visual Basic et C++ suivant.

class C
{
    T N<T,U>(T t, U u) {...}
    public V M<V>(V v)
    {
        return N<V,int>(v, 42);
    }
}

Class C
    Public Function N(Of T,U)(ByVal ta As T, ByVal ua As U) As T
        ...
    End Function
    Public Function M(Of V)(ByVal va As V ) As V
        Return N(Of V, Integer)(va, 42)
    End Function
End Class

ref class C
{
private:
    generic <typename T, typename U> T N(T t, U u) {...}
public:
    generic <typename V> V M(V v)
    {
        return N<V, int>(v, 42);
    }
};

Le corps de la méthode de M contient un appel à la méthode N, spécifiant le paramètre type de M et le type Int32. La IsGenericMethodDefinition propriété retourne false pour la méthode N<V,int>. La ContainsGenericParameters propriété retourne true, de sorte que la méthode N<V,int> ne peut pas être appelée.

Pour obtenir la liste des conditions invariantes pour les termes spécifiques aux méthodes génériques, consultez la IsGenericMethod propriété . Pour obtenir la liste des conditions invariantes pour d’autres termes utilisés dans la réflexion générique, consultez la IsGenericType propriété .

S’applique à

Voir aussi

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• Réflexion et types génériques
• Introduction aux génériques (guide de programmation C#)