MethodBuilder.MakeGenericMethod メソッド

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

MethodBuilder.MakeGenericMethod メソッド

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

指定したジェネリック型引数を使用して、現在のジェネリック メソッドの定義から構築されたジェネリック メソッドを返します。

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

Visual Basic (宣言)

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

Visual Basic (使用法)

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

returnValue = instance.MakeGenericMethod(typeArguments)

C#

public override MethodInfo MakeGenericMethod (
    params Type[] typeArguments
)

C++

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

J#

public MethodInfo MakeGenericMethod (
    Type[] typeArguments
)

JScript

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

パラメータ

typeArguments

ジェネリック メソッドの型引数を表す Type オブジェクトの配列。

戻り値
指定したジェネリック型引数を使用して、現在のジェネリック メソッドの定義から構築されたジェネリック メソッドを表す MethodInfo。

解説

動的コードを出力するときには、外側の型を完了する前に、MethodBuilder によって表されるジェネリック メソッドの定義から構築されたメソッドの呼び出しを出力することが必要な場合があります。MakeGenericMethod メソッドを使用すると、このような構築されたメソッドの MethodInfo を作成し、出力された呼び出しで MethodInfo を使用できます。

使用例

不完全な型の不完全なジェネリック メソッドの定義から構築されたメソッドを作成するコード例を次に示します。

この例では、単一の型で遷移的アセンブリとモジュールを作成し、M メソッドを追加します。次に、DefineGenericParameters メソッドを使用して型パラメータ T を追加することによってメソッドをジェネリックにします。型パラメータは、メソッドのパラメータの型として使用され、戻り値の型としても使用されます。ジェネリック メソッドの定義には本体は提供されず、外側の型は完了しません。次に、MakeGenericMethod メソッドを使用して、構築されたメソッド M<String> (Visual Basic では M(Of String)) を作成します。MakeGenericMethod メソッドによって返される MethodInfo のサブクラスでは、パラメータに対してリフレクションを実行できないため、このコードには出力はありません。

メモ
MakeGenericMethod を使用した他のコード例については、DefineGenericParameters のトピックを参照してください。また、MakeGenericMethod は、ジェネリック型を使ったコードを出力する用途でも幅広く使用されます。詳細については、方法 : リフレクション出力を使用してジェネリック メソッドを定義する のトピックを参照してください。

Visual Basic

Imports System
Imports System.Reflection
Imports System.Reflection.Emit

Class Example

    Public Shared Sub Main()
    
        ' Define a transient dynamic assembly (only to run, not
        ' to save) with one module and a type "Test".
        ' 
        Dim aName As AssemblyName = New
 AssemblyName("MyDynamic")
        Dim ab As AssemblyBuilder = _
            AppDomain.CurrentDomain.DefineDynamicAssembly( _
                aName, _
                AssemblyBuilderAccess.Run)
        Dim mb As ModuleBuilder = ab.DefineDynamicModule(aName.Name)
        Dim tb As TypeBuilder = mb.DefineType("Test")

        ' Add a Public Shared method "M" to Test, and make
 it a
        ' generic method with one type parameter named "T").
        '
        Dim meb As MethodBuilder = tb.DefineMethod("M",
 _
            MethodAttributes.Public Or MethodAttributes.Static)
        Dim typeParams() As GenericTypeParameterBuilder
 = _
            meb.DefineGenericParameters(New String()
 { "T" })

        ' Give the method one parameter, of type T, and a 
        ' return type of T.
        meb.SetParameters(typeParams)
        meb.SetReturnType(typeParams(0))

        ' Create a MethodInfo for M(Of String), which can be used 
        ' in emitted code. This is possible even though the method
        ' does not yet have a body, and the enclosing type is not
        ' created.
        Dim mi As MethodInfo = _
            meb.MakeGenericMethod(GetType(String))
        ' Note that this is actually a subclass of MethodInfo, 
        ' which has rather limited capabilities -- for
        ' example, you cannot reflect on its parameters.
    End Sub
End Class

C#

using System;
using System.Reflection;
using System.Reflection.Emit;

class Example
{
    public static void Main()
    {
        // Define a transient dynamic assembly (only to run, not
        // to save) with one module and a type "Test".
        // 
        AssemblyName aName = new AssemblyName("MyDynamic");
        AssemblyBuilder ab = 
            AppDomain.CurrentDomain.DefineDynamicAssembly(
                aName, 
                AssemblyBuilderAccess.Run);
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
        TypeBuilder tb = mb.DefineType("Test");

        // Add a public static method "M" to Test, and make
 it a
        // generic method with one type parameter named "T").
        //
        MethodBuilder meb = tb.DefineMethod("M", 
            MethodAttributes.Public | MethodAttributes.Static);
        GenericTypeParameterBuilder[] typeParams = 
            meb.DefineGenericParameters(new string[]
 { "T" });

        // Give the method one parameter, of type T, and a 
        // return type of T.
        meb.SetParameters(typeParams);
        meb.SetReturnType(typeParams[0]);

        // Create a MethodInfo for M<string>, which can be used
 in
        // emitted code. This is possible even though the method
        // does not yet have a body, and the enclosing type is not
        // created.
        MethodInfo mi = meb.MakeGenericMethod(typeof(string));
        // Note that this is actually a subclass of MethodInfo, 
        // which has rather limited capabilities -- for
        // example, you cannot reflect on its parameters.
    }
}

C++

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void main()
{
    // Define a transient dynamic assembly (only to run, not
    // to save) with one module and a type "Test".
    // 
    AssemblyName^ aName = gcnew AssemblyName("MyDynamic");
    AssemblyBuilder^ ab = 
        AppDomain::CurrentDomain->DefineDynamicAssembly(
            aName, 
            AssemblyBuilderAccess::Run);
    ModuleBuilder^ mb = ab->DefineDynamicModule(aName->Name);
    TypeBuilder^ tb = mb->DefineType("Test");

    // Add a public static method "M" to Test, and make it
 a
    // generic method with one type parameter named "T").
    //
    MethodBuilder^ meb = tb->DefineMethod("M", 
        MethodAttributes::Public | MethodAttributes::Static);
    array<GenericTypeParameterBuilder^>^ typeParams = 
        meb->DefineGenericParameters(gcnew array<String^> { "T"
 });

    // Give the method one parameter, of type T, and a 
    // return type of T.
    meb->SetParameters(typeParams);
    meb->SetReturnType(typeParams[0]);

    // Create a MethodInfo for M<string>, which can be used in
    // emitted code. This is possible even though the method
    // does not yet have a body, and the enclosing type is not
    // created.
    MethodInfo^ mi = meb->MakeGenericMethod(String::typeid);
    // Note that this is actually a subclass of MethodInfo, 
    // which has rather limited capabilities -- for
    // example, you cannot reflect on its parameters.
}

プラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0

参照

関連項目
MethodBuilder クラス
MethodBuilder メンバ
System.Reflection.Emit 名前空間
その他の技術情報
方法 : リフレクション出力を使用してジェネリック メソッドを定義する