MethodInfo.MakeGenericMethod(Type[]) 方法 (System.Reflection)

相关文章推荐

帅呆的豌豆 · 段奥娟搜索页-e站影院· 2 月前 ·

腼腆的松球 · 双桥区人民政府领导活动、会议讲话2022年度 ...· 6 月前 ·

风流的沙滩裤 · will.i.am Debuts ...· 8 月前 ·

买醉的海豚 · [2020全球百大DJ]REZZ | ...· 11 月前 ·

玉树临风的斑马 · 农业考古· 1 年前 ·

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

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

abstract member MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo

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

generic<typename T> static void Generic(T toDisplay) Console::WriteLine("\r\nHere it is: {0}", toDisplay); 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) array<Type^>^ typeArguments = mi->GetGenericArguments(); Console::WriteLine("\tList type arguments ({0}):", typeArguments->Length); for each (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); Console::WriteLine("\t\t{0}", tParam); 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 = Example::typeid; MethodInfo^ mi = ex->GetMethod("Generic"); DisplayGenericMethodInfo(mi); // Assign the int type to the type parameter of the Example // method. MethodInfo^ miConstructed = mi->MakeGenericMethod(int::typeid); DisplayGenericMethodInfo(miConstructed); // Invoke the method. array<Object^>^ args = { 42 }; miConstructed->Invoke((Object^) 0, 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); /* 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


   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);
                    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)
                    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
    
     方法
     
      MakeGenericMethod
     
     允许编写将特定类型分配给泛型方法定义的类型参数的代码，从而创建表示
     
      MethodInfo
     
     特定构造方法的对象。
     
      ContainsGenericParameters
     
     如果此
     
      MethodInfo
     
     对象的 属性返回
     
      true
     
     ，则可以使用它调用 方法或创建委托来调用 方法。
    
    
     使用
     
      MakeGenericMethod
     
     方法构造的方法可以打开，也就是说，其某些类型参数可以是封闭泛型类型的类型参数。 生成动态程序集时，可以使用此类开放式构造方法。 例如，请考虑以下 C#、Visual Basic 和 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);  
的方法主体 M 包含对 方法 N的调用，指定 的 M 类型参数和类型 Int32。 属性IsGenericMethodDefinition为 方法 N<V,int>返回 false 。 属性 ContainsGenericParameters 返回 true，因此无法调用 方法 N<V,int> 。
有关特定于泛型方法的术语的固定条件列表，请参阅 IsGenericMethod 属性。 有关泛型反射中使用的其他术语的固定条件列表，请参阅 IsGenericType 属性。