MethodInfo.MakeGenericMethod(Type[]) 方法

定義

命名空間:

System.Reflection

組件:

netstandard.dll, System.Runtime.dll

來源:

MethodInfo.cs

將型別陣列中的元素替換為目前通用方法定義的型別參數，並回傳 MethodInfo 一個代表所建構方法的物件。

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

參數

typeArguments

Type[]

一組型別陣列，將替換當前通用方法定義的型別參數。

傳回

MethodInfo

一個 MethodInfo 物件，代表由將 的 typeArguments 元素替換為當前通用方法定義的型別參數所構成的建構方法。

屬性

RequiresDynamicCodeAttribute RequiresUnreferencedCodeAttribute

例外狀況

InvalidOperationException

目前的定義 MethodInfo 並不代表通用的方法定義。 也就是說，回歸 IsGenericMethodDefinitionfalse。

ArgumentNullException

typeArguments 為 null。

-或-

任何元素 typeArguments 都是 null。

ArgumentException

元素 typeArguments 的數量與目前通用方法定義的型別參數數不同。

-或-

元素 typeArguments 的某個元素不符合目前通用方法定義中對應型別參數所規定的限制條件。

NotSupportedException

此方法不被支援。

範例

以下程式碼範例展示了支援檢視泛型方法的 MethodInfo 特性與方法。 這個例子做了以下事情：

• 定義了一個具有通用方法的類別。
• 建立 MethodInfo 一個代表通用方法的 。
• 顯示通用方法定義的性質。
• 將型別參數指派給 的型別參數 MethodInfo，並呼叫所產生的構造通用方法。
• 顯示構造通用方法的特性。
• 從建構方法中檢索通用方法定義，並與原始定義比較。

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
'

備註

這個 MakeGenericMethod 方法允許你撰寫程式碼，將特定型別指派給通用方法定義的型別參數，從而建立 MethodInfo 一個代表特定建構方法的物件。 如果這個MethodInfo物件的屬性回ContainsGenericParameters傳 true，你可以用它來呼叫該方法，或建立代理來呼叫該方法。

使用該 MakeGenericMethod 方法構建的方法可以是開放式的，也就是說，它們的部分型別參數可以是包圍泛型型別的型別參數。 你可以在產生動態組合時使用這種開放構造的方法。 例如，試想下列程式碼。

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

的方法 M 主體包含對方法 N的呼叫，指定了 的 M 型別參數 和型別 Int32。 對於方法N<V,int>，屬性會IsGenericMethodDefinition回傳false。 屬性會 ContainsGenericParameters 回傳 true，因此無法呼叫方法 N<V,int> 。

關於通用方法專有項不變條件的列表，請參見性質。IsGenericMethod 關於一般反射中其他術語不變條件的列表，請參見性質。IsGenericType

另請參閱

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• 反射和泛型型別
• 通用文學入門（C# 程式指南）