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

相关文章推荐

坚韧的哑铃 · uni-app图片选择转base64问题，H ...· 1 年前 ·

霸气的白开水 · C# Linq ...· 2 年前 ·

玉树临风的楼房 · 常用内置函数· 2 年前 ·

安静的热水瓶 · 如何使用OpenCV 顯示視訊串流 - ...· 2 年前 ·

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 方法的屬性 false N<V,int> 。 ContainsGenericParameters屬性會傳回 true ，因此 N<V,int> 無法叫用方法。
如需泛型方法特定詞彙的非變異條件清單，請參閱 IsGenericMethod 屬性。 如需一般反映中所使用之其他詞彙的非變異條件清單，請參閱 IsGenericType 屬性。