Esporta (0) Stampa
Espandi tutto

Metodo MethodInfo.MakeGenericMethod

Aggiornamento: novembre 2007

Sostituisce con gli elementi di una matrice di tipi i parametri di tipo della definizione di metodo generica corrente e restituisce un oggetto MethodInfo che rappresenta il metodo costruito risultante.

Spazio dei nomi:  System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

public virtual MethodInfo MakeGenericMethod(
	params Type[] typeArguments
)
public MethodInfo MakeGenericMethod(
	Type[] typeArguments
)
public function MakeGenericMethod(
	... typeArguments : Type[]
) : MethodInfo

Parametri

typeArguments
Tipo: System.Type[]

Matrice di tipi con cui sostituire i parametri di tipo della definizione del metodo generica corrente.

Valore restituito

Tipo: System.Reflection.MethodInfo

Oggetto MethodInfo che rappresenta il metodo costruito ottenuto sostituendo gli elementi di typeArguments per i parametri di tipo della definizione di metodo generica corrente.

EccezioneCondizione
InvalidOperationException

La classe MethodInfo corrente non rappresenta una definizione di metodo generica, ovvero la proprietà IsGenericMethodDefinition restituisce false.

ArgumentNullException

typeArguments è null.

-oppure-

Qualsiasi elemento di typeArguments è null.

ArgumentException

Il numero di elementi in typeArguments non corrisponde al numero di parametri di tipo nella definizione del metodo generica corrente.

-oppure-

Uno degli elementi di typeArguments non soddisfa i vincoli specificati per il parametro di tipo corrispondente della definizione di metodo generica corrente.

NotSupportedException

Questo metodo non è supportato.

Il metodo MakeGenericMethod consente di scrivere codice per assegnare tipi specifici ai parametri di tipo di una definizione di metodo generica, creando così un oggetto MethodInfo che rappresenta un determinato metodo costruito. Se la proprietà ContainsGenericParameters dell'oggetto MethodInfo restituisce true, è possibile utilizzarla per richiamare il metodo o per creare un delegato che richiami il metodo.

I metodi costruiti con il metodo MakeGenericMethod possono essere aperti, ovvero alcuni dei relativi argomenti di tipo possono essere parametri di tipo di tipi di inclusione generici. È possibile utilizzare tali metodi costruiti aperti in occasione della creazione di assembly dinamici. Si prenda in considerazione, ad esempio, il seguente codice C#, Visual Basic e C++:

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);
    }
};

Il corpo del metodo di M contiene una chiamata al metodo N, che specifica il parametro di tipo di M e il tipo Int32. La proprietà IsGenericMethodDefinition restituisce false per il metodo N<V,int>. Se la proprietà ContainsGenericParameters restituisce true, non è possibile richiamare il metodo N<V,int>.

Per un elenco delle condizioni invarianti relative a termini specifici dei metodi generici, vedere la proprietà IsGenericMethod. Per un elenco delle condizioni invarianti relative ad altri termini utilizzati nella reflection generica, vedere la proprietà IsGenericType.

Nell'esempio di codice riportato di seguito vengono illustrati le proprietà e i metodi della classe MethodInfo che supportano l'analisi di metodi generici. Nell'esempio vengono effettuate le seguenti operazioni:

  • Viene definita una classe in cui è presente un metodo generico.

  • Viene creata una classe MethodInfo che rappresenta il metodo generico.

  • Vengono visualizzate le proprietà della definizione del metodo generica.

  • Vengono assegnati gli argomenti di tipo ai parametri di tipo della classe MethodInfo e viene richiamato il metodo generico costruito risultante.

  • Vengono visualizzate le proprietà del metodo generico costruito.

  • La definizione del metodo generica viene recuperata dal metodo costruito e confrontata con la definizione iniziale.

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

 */


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC, Xbox 360

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0

.NET Compact Framework

Supportato in: 3.5, 2.0

XNA Framework

Supportato in: 2.0, 1.0

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft