MethodInfo.MakeGenericMethod メソッドとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

MethodInfo.MakeGenericMethod メソッド

メモ : このメソッドは、.NET Framework version 2.0 で新しく追加されたものです。

型の配列の要素を現在のジェネリックメソッド定義の型パラメータで置き換え、結果の構築メソッドを表す MethodInfo オブジェクトを返します。

名前空間: System.Reflection
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

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

Visual Basic (使用法)

Dim instance As MethodInfo
Dim typeArguments As Type()
Dim returnValue As MethodInfo

returnValue = instance.MakeGenericMethod(typeArguments)

public virtual MethodInfo MakeGenericMethod (
    params Type[] typeArguments
)

C++

public:
virtual MethodInfo^ MakeGenericMethod (
    ... array<Type^>^ typeArguments
)

public MethodInfo MakeGenericMethod (
    Type[] typeArguments
)

JScript

public function MakeGenericMethod (
    ... typeArguments : Type[]
) : MethodInfo

パラメータ

typeArguments: 現在のジェネリックメソッド定義の型パラメータに置き換えられる型の配列。

戻り値
typeArguments の要素を現在のジェネリックメソッド定義の型パラメータで置き換えることによって作られる構築メソッドを表す MethodInfo オブジェクト。

例外

例外の種類	条件
InvalidOperationException	現在の MethodInfo はジェネリックメソッド定義を表しません。つまり、IsGenericMethodDefinition は false を返します。
ArgumentNullException	typeArguments が null 参照 (Visual Basic では Nothing) です。または typeArguments の要素が null 参照 (Visual Basic では Nothing) です。
ArgumentException	typeArguments の要素の数が、現在のジェネリックメソッド定義の型パラメータの数と同じではありません。または typeArguments の要素が、現在のジェネリックメソッド定義の対応する型パラメータに対して指定された制約を満たしていません。

例外の種類

条件

InvalidOperationException

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

ArgumentNullException

typeArguments が null 参照 (Visual Basic では Nothing) です。

または

typeArguments の要素が null 参照 (Visual Basic では Nothing) です。

ArgumentException

typeArguments の要素の数が、現在のジェネリックメソッド定義の型パラメータの数と同じではありません。

または

typeArguments の要素が、現在のジェネリックメソッド定義の対応する型パラメータに対して指定された制約を満たしていません。

解説

MakeGenericMethod メソッドにより、ジェネリックメソッド定義の型パラメータに特定の型を割り当てるコードを記述して、特定の構築メソッドを表す MethodInfo オブジェクトを作成できます。この MethodInfo オブジェクトの ContainsGenericParameters プロパティが 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 のメソッド本体には、M の型パラメータおよび Int32 型を指定した、N メソッドへの呼び出しが格納されます。IsGenericMethodDefinition プロパティは、N<V,int> メソッドに対して false を返します。ContainsGenericParameters プロパティが true を返す場合、N<V,int> メソッドを呼び出すことはできません。

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

使用例

ジェネリックメソッドのチェックをサポートする MethodInfo のプロパティおよびメソッドのコード例を次に示します。この例では次の処理を行います。

ジェネリックメソッドを保持するクラスを定義します。
ジェネリックメソッドを表す MethodInfo を作成します。
ジェネリックメソッド定義のプロパティを表示します。
MethodInfo の型パラメータに型引数を割り当て、結果として構築されるジェネリックメソッドを呼び出します。
構築されたジェネリックメソッドのプロパティを表示します。
構築メソッドからジェネリックメソッド定義を取得し、元の定義と比較します。

Visual Basic

Imports System
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 'Main
      
    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
'

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

 */

C++

using namespace System;
using namespace System::Reflection;

// Define a class with a generic method.
ref class Example
{
public:
    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);
            }
            else
            {
                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

 */