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

現在のジェネリック メソッド定義の型パラメーターに対してtypeArgumentsの要素を置き換えることによって形成される、構築されたメソッドを表すMethodInfo オブジェクト。

属性

RequiresDynamicCodeAttribute RequiresUnreferencedCodeAttribute

例外

InvalidOperationException

現在の MethodInfo はジェネリック メソッド定義を表していません。 つまり、 IsGenericMethodDefinition は falseを返します。

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型を指定します。 IsGenericMethodDefinition プロパティは、メソッド N<V,int>のfalseを返します。 ContainsGenericParameters プロパティはtrueを返すので、メソッドN<V,int>を呼び出すことはできません。

ジェネリック メソッドに固有の用語の不変条件の一覧については、 IsGenericMethod プロパティを参照してください。 ジェネリック リフレクションで使用される他の用語の不変条件の一覧については、 IsGenericType プロパティを参照してください。

こちらもご覧ください

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• リフレクション型とジェネリック型
• ジェネリックの概要 (C# プログラミング ガイド)