MethodInfo.MakeGenericMethod(Type[]) Metódus

Definíció

Névtér:

System.Reflection

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

MethodInfo.cs

Az aktuális általános metódusdefiníció típusparamétereinek egy típusok tömbjének elemeit helyettesíti, és visszaad egy MethodInfo objektumot, amely az eredményül kapott létrehozott metódust képviseli.

public:
 virtual System::Reflection::MethodInfo ^ MakeGenericMethod(... cli::array <Type ^> ^ typeArguments);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
public virtual System.Reflection.MethodInfo MakeGenericMethod(params Type[] typeArguments);

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")>]
[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")>]
abstract member MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo

Public Overridable Function MakeGenericMethod (ParamArray typeArguments As Type()) As MethodInfo

Paraméterek

typeArguments

Type[]

Az aktuális általános metódusdefiníció típusparaméterei helyett helyettesítendő típusok tömbje.

Válaszok

MethodInfo

Olyan MethodInfo objektum, amely az aktuális általános metódusdefiníció típusparamétereinek typeArguments elemeinek helyettesítésével létrehozott létrehozott metódust jelöli.

Attribútumok

RequiresDynamicCodeAttribute RequiresUnreferencedCodeAttribute

Kivételek

InvalidOperationException

Az aktuális MethodInfo nem általános metódusdefiníciót jelöl. Vagyis IsGenericMethodDefinition visszaadja false.

ArgumentNullException

typeArguments az null.

-vagy-

Az elem bármely elemetypeArguments.null

ArgumentException

A benne lévő typeArguments elemek száma nem azonos az aktuális általános metódusdefiníció típusparamétereinek számával.

-vagy-

Egy elem typeArguments nem felel meg az aktuális általános metódusdefiníció megfelelő típusparaméteréhez megadott megkötéseknek.

NotSupportedException

Ez a módszer nem támogatott.

Példák

Az alábbi példakód bemutatja azokat a tulajdonságokat és módszereket MethodInfo , amelyek támogatják az általános módszerek vizsgálatát. A példa a következőket teszi:

• Általános metódussal rendelkező osztályt definiál.
• Létrehoz egy olyan értéket MethodInfo , amely az általános metódust jelöli.
• Megjeleníti az általános metódusdefiníció tulajdonságait.
• Típusargumentumokat rendel a típusparaméterekhez MethodInfo, és meghívja az eredményként létrehozott általános metódust.
• Megjeleníti a létrehozott általános metódus tulajdonságait.
• Lekéri az általános metódusdefiníciót a létrehozott metódusból, és összehasonlítja az eredeti definícióval.

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

 */

Imports System.Reflection

' Define a class with a generic method.
Public Class Example
    Public Shared Sub Generic(Of T)(ByVal toDisplay As T)
        Console.WriteLine(vbCrLf & "Here it is: {0}", toDisplay)
    End Sub
End Class

Public Class Test
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf & "--- Examine a generic method.")
        
        ' Create a Type object representing class Example, and
        ' get a MethodInfo representing the generic method.
        '
        Dim ex As Type = GetType(Example)
        Dim mi As MethodInfo = ex.GetMethod("Generic")
        
        DisplayGenericMethodInfo(mi)
        
        ' Assign the Integer type to the type parameter of the Example 
        ' method.
        '
        Dim arguments() As Type = { GetType(Integer) }
        Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)
        
        DisplayGenericMethodInfo(miConstructed)

        ' Invoke the method.
        Dim args() As Object = { 42 }
        miConstructed.Invoke(Nothing, args)
        
        ' Invoke the method normally.
        Example.Generic(Of Integer)(42)
        
        ' Get the generic type definition from the constructed method,
        ' and show that it's the same as the original definition.
        '
        Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
        Console.WriteLine(vbCrLf & "The definition is the same: {0}", _
            miDef Is mi)
    End Sub
      
    Private Shared Sub DisplayGenericMethodInfo(ByVal mi As MethodInfo) 
        Console.WriteLine(vbCrLf & mi.ToString())
        
        Console.WriteLine(vbTab _
            & "Is this a generic method definition? {0}", _
            mi.IsGenericMethodDefinition)

        Console.WriteLine(vbTab & "Is it a generic method? {0}", _
            mi.IsGenericMethod)

        Console.WriteLine(vbTab _
            & "Does it have unassigned generic parameters? {0}", _
            mi.ContainsGenericParameters)

        ' If this is a generic method, display its type arguments.
        '
        If mi.IsGenericMethod Then
            Dim typeArguments As Type() = mi.GetGenericArguments()
            
            Console.WriteLine(vbTab & "List type arguments ({0}):", _
                typeArguments.Length)
            
            For Each tParam As Type In typeArguments
                ' IsGenericParameter is true only for generic type
                ' parameters.
                '
                If tParam.IsGenericParameter Then
                    Console.WriteLine(vbTab & vbTab _
                        & "{0}  parameter position: {1}" _
                        & vbCrLf & vbTab & vbTab _
                        & "   declaring method: {2}", _
                        tParam,  _
                        tParam.GenericParameterPosition, _
                        tParam.DeclaringMethod)
                Else
                    Console.WriteLine(vbTab & vbTab & tParam.ToString())
                End If
            Next tParam
        End If
    End Sub 
End Class 

' 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
'

Megjegyzések

A MakeGenericMethod metódus lehetővé teszi olyan kód írását, amely meghatározott típusokat rendel egy általános metódusdefiníció típusparamétereihez, így létrehoz egy MethodInfo objektumot, amely egy adott létrehozott metódust jelöl. Ha ennek ContainsGenericParameters az objektumnak a MethodInfo tulajdonsága visszakerültrue, meghívhatja a metódust, vagy létrehozhat egy meghatalmazottat a metódus meghívásához.

A metódussal MakeGenericMethod létrehozott metódusok nyitottak lehetnek, vagyis egyes típusargumentumok lehetnek az általános típusokat tartalmazó típusparaméterek. Dinamikus szerelvények létrehozásakor ilyen nyíltan létrehozott módszereket is használhat. Vegyük például az alábbi kódot.

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

A metódus törzse M egy metódushívást Ntartalmaz, amely megadja a típusparamétert M és a típust Int32. A IsGenericMethodDefinition tulajdonság a metódus falseértékét adja visszaN<V,int>. A ContainsGenericParameters tulajdonság visszaadja, trueígy a metódus N<V,int> nem hívható meg.

Az általános metódusokra vonatkozó kifejezések invariáns feltételeinek listáját a IsGenericMethod tulajdonságban találja. Az általános tükrözésben használt egyéb kifejezések invariáns feltételeinek listáját a IsGenericType tulajdonságban találja.

Lásd még

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• Reflexió és generikus típusok
• Bevezetés a Generics használatába (C# programozási útmutató)