TypeBuilder.GetMethod(Type, MethodInfo) メソッド

定義

ジェネリック型定義の指定されたメソッドに対応する、指定の構築されたジェネリック型のメソッドを返します。Returns the method of the specified constructed generic type that corresponds to the specified method of the generic type definition.

public:
 static System::Reflection::MethodInfo ^ GetMethod(Type ^ type, System::Reflection::MethodInfo ^ method);
public static System.Reflection.MethodInfo GetMethod (Type type, System.Reflection.MethodInfo method);
static member GetMethod : Type * System.Reflection.MethodInfo -> System.Reflection.MethodInfo

パラメーター

type
Type

メソッドが返される構築されたジェネリック型。The constructed generic type whose method is returned.

method
MethodInfo

返す type のメソッドを指定する、type のジェネリック型定義のメソッド。A method on the generic type definition of type, which specifies which method of type to return.

戻り値

MethodInfo のジェネリック型定義に属するメソッドを指定する、type に対応する method のメソッドを表す type オブジェクト。A MethodInfo object that represents the method of type corresponding to method, which specifies a method belonging to the generic type definition of type.

例外

method はジェネリック メソッド定義ではないジェネリック メソッドです。method is a generic method that is not a generic method definition.

または-or- type がジェネリック型を表していません。type does not represent a generic type.

または-or- typeTypeBuilder 型ではありません。type is not of type TypeBuilder.

または-or- method の宣言する型はジェネリック型定義ではありません。The declaring type of method is not a generic type definition.

または-or- method の宣言する型は type のジェネリック型定義ではありません。The declaring type of method is not the generic type definition of type.

次のコード例には、Tという型パラメーターを持つ Sample という名前のジェネリッククラスのソースコードが含まれています。The following code example contains source code for a generic class named Sample that has a type parameter named T. クラスには、T型の Fieldという名前のフィールドと、Uという名前の独自の型パラメーターを持つ GM という名前のジェネリックメソッドがあります。The class has a field named Field, of type T, and a generic method named GM with its own type parameter, named U. メソッド GM は、Sampleのインスタンスを作成し、Sampleの型パラメーターに対して独自の型パラメーター U を置き換え、その入力パラメーターを Fieldに格納します。Method GM creates an instance of Sample, substituting its own type parameter U for the type parameter of Sample, and stores its input parameter in Field. このソースコードはコンパイルされていますが、使用されていません。ildasm.exe (IL 逆アセンブラー)を使用して表示し、Exampleクラスによって出力されたコードと比較することができます。This source code is compiled but not used; you can view it with the Ildasm.exe (IL Disassembler) and compare it to the code emitted by class Example.

クラス Example のコードは、GetMethod メソッドを使用してジェネリックコードを出力する方法を示しています。The code in class Example demonstrates the use of the GetMethod method to emit generic code. クラス ExampleMain メソッドは、Sample という名前のクラスを含む動的アセンブリを作成し、Tという名前の型パラメーターを追加することによって、DefineGenericParameters メソッドを使用してジェネリックにします。The Main method of class Example creates a dynamic assembly containing a class named Sample and uses the DefineGenericParameters method to make it generic by adding a type parameter named T. パラメーターなしのコンストラクターと、T型の Fieldという名前のフィールドがクラス Sampleに追加されます。A parameterless constructor and a field named Field, of type T, are added to class Sample. メソッド GM は、MethodBuilder.DefineGenericParameters メソッドを使用して、ジェネリックメソッドに追加されています。A method GM is added and turned into a generic method by using the MethodBuilder.DefineGenericParameters method. GM の型パラメーターに Uという名前が付けられています。The type parameter of GM is named U. 型パラメーターを定義した後、GM のシグネチャは、MethodBuilder.SetSignature メソッドを使用して追加されます。After the type parameter is defined, the signature of GM is added by using the MethodBuilder.SetSignature method. 戻り値の型はなく、必須またはカスタムの修飾子もないため、このメソッドのすべてのパラメーターは parameterTypesを除くすべて null ます。メソッドの唯一のパラメーターの型を、メソッドのジェネリック型パラメーターである UparameterTypes 設定します。There is no return type and no required or custom modifiers, so all the parameters of this method are null except parameterTypes; parameterTypes sets the type of the method's only parameter to U, the method's generic type parameter. メソッドの本体は、構築された型 Sample<U> (Visual Basic でSample(Of U)) のインスタンスを作成し、メソッドのパラメーターを Fieldに割り当ててから Fieldの値を出力します。The body of the method creates an instance of the constructed type Sample<U> (Sample(Of U) in Visual Basic), assigns the method's parameter to Field, and then prints the value of Field. ダミー型は、エントリポイントメソッド Mainを保持するように定義されています。A dummy type is defined to hold the entry-point method Main. Mainの本体では、静的な GM メソッドが、Visual Basic に置き換えられた型 String を使用して構築されたジェネリック型 Sample<int> (USample(Of Integer)) で呼び出されます。In the body of Main, the static GM method is invoked on the constructed generic type Sample<int> (Sample(Of Integer) in Visual Basic), with type String substituted for U. GetMethod メソッドは、構築されたジェネリック型 Sample<U>の静的 GM メソッドの MethodInfo を作成するために使用されます。その後、メソッドを使用して、メソッド呼び出しで出力できる MethodInfo.MakeGenericMethod を作成します。MethodInfoThe GetMethod method is used to create a MethodInfo for the static GM method of the constructed generic type Sample<U>, and the MethodInfo.MakeGenericMethod method is then used to create a MethodInfo that can emitted in a method call.

コード例を実行すると、生成されたアセンブリが TypeBuilderGetFieldExample として保存されます。When the code example is run, it saves the emitted assembly as TypeBuilderGetFieldExample.exe. TypeBuilderGetFieldExample を実行すると、 ildasm.exe (IL 逆アセンブラー)を使用して、出力されたコードと、コード例自体にコンパイルされた Sample クラスのコードを比較できます。You can run TypeBuilderGetFieldExample.exe, and you can use the Ildasm.exe (IL Disassembler) to compare the emitted code with the code for the Sample class that is compiled into the code example itself.

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

// Compare the MSIL in this class to the MSIL
// generated by the Reflection.Emit code in class
// Example.
public class Sample<T>
{
  public T Field;
  public static void GM<U>(U val)
  {
    Sample<U> s = new Sample<U>();
    s.Field = val;
    Console.WriteLine(s.Field);
  }
}

public class Example
{
    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = 
            new AssemblyName("TypeBuilderGetFieldExample");
        AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(
            myAsmName, AssemblyBuilderAccess.Save);
        ModuleBuilder myModule = myAssembly.DefineDynamicModule(
            myAsmName.Name, 
            myAsmName.Name + ".exe");

        // Define the sample type.
        TypeBuilder myType = myModule.DefineType("Sample", 
            TypeAttributes.Class | TypeAttributes.Public);

        // Add a type parameter, making the type generic.
        string[] typeParamNames = {"T"};  
        GenericTypeParameterBuilder[] typeParams = 
            myType.DefineGenericParameters(typeParamNames);

        // Define a default constructor. Normally it would 
        // not be necessary to define the default constructor,
        // but in this case it is needed for the call to
        // TypeBuilder.GetConstructor, which gets the default
        // constructor for the generic type constructed from 
        // Sample<T>, in the generic method GM<U>.
        ConstructorBuilder ctor = myType.DefineDefaultConstructor(
            MethodAttributes.PrivateScope | MethodAttributes.Public |
            MethodAttributes.HideBySig | MethodAttributes.SpecialName |
            MethodAttributes.RTSpecialName);

        // Add a field of type T, with the name Field.
        FieldBuilder myField = myType.DefineField("Field", 
            typeParams[0],
            FieldAttributes.Public);

        // Add a method and make it generic, with a type 
        // parameter named U. Note how similar this is to 
        // the way Sample is turned into a generic type. The
        // method has no signature, because the type of its
        // only parameter is U, which is not yet defined.
        MethodBuilder genMethod = myType.DefineMethod("GM", 
            MethodAttributes.Public | MethodAttributes.Static);
        string[] methodParamNames = {"U"};
        GenericTypeParameterBuilder[] methodParams = 
            genMethod.DefineGenericParameters(methodParamNames);
        
        // Now add a signature for genMethod, specifying U
        // as the type of the parameter. There is no return value
        // and no custom modifiers.
        genMethod.SetSignature(null, null, null, 
            new Type[] { methodParams[0] }, null, null);

        // Emit a method body for the generic method.
        ILGenerator ilg = genMethod.GetILGenerator();
        // Construct the type Sample<U> using MakeGenericType.
        Type SampleOfU = myType.MakeGenericType( methodParams[0] );
        // Create a local variable to store the instance of
        // Sample<U>.
        ilg.DeclareLocal(SampleOfU);
        // Call the default constructor. Note that it is 
        // necessary to have the default constructor for the
        // constructed generic type Sample<U>; use the 
        // TypeBuilder.GetConstructor method to obtain this 
        // constructor.
        ConstructorInfo ctorOfU = TypeBuilder.GetConstructor(
            SampleOfU, ctor);
        ilg.Emit(OpCodes.Newobj, ctorOfU);
        // Store the instance in the local variable; load it
        // again, and load the parameter of genMethod.
        ilg.Emit(OpCodes.Stloc_0); 
        ilg.Emit(OpCodes.Ldloc_0); 
        ilg.Emit(OpCodes.Ldarg_0);
        // In order to store the value in the field of the
        // instance of Sample<U>, it is necessary to have 
        // a FieldInfo representing the field of the 
        // constructed type. Use TypeBuilder.GetField to 
        // obtain this FieldInfo.
        FieldInfo FieldOfU = TypeBuilder.GetField(
            SampleOfU, myField);
        // Store the value in the field. 
        ilg.Emit(OpCodes.Stfld, FieldOfU);
        // Load the instance, load the field value, box it
        // (specifying the type of the type parameter, U), and
        // print it.
        ilg.Emit(OpCodes.Ldloc_0);
        ilg.Emit(OpCodes.Ldfld, FieldOfU);
        ilg.Emit(OpCodes.Box, methodParams[0]);
        MethodInfo writeLineObj = 
            typeof(Console).GetMethod("WriteLine", 
                new Type[] { typeof(object) });
        ilg.EmitCall(OpCodes.Call, writeLineObj, null);
        ilg.Emit(OpCodes.Ret);

        // Emit an entry point method; this must be in a
        // non-generic type.
        TypeBuilder dummy = myModule.DefineType("Dummy", 
            TypeAttributes.Class | TypeAttributes.NotPublic);
        MethodBuilder entryPoint = dummy.DefineMethod("Main", 
            MethodAttributes.Public | MethodAttributes.Static,
            null, null);
        ilg = entryPoint.GetILGenerator();
        // In order to call the static generic method GM, it is
        // necessary to create a constructed type from the 
        // generic type definition for Sample. This can be any
        // constructed type; in this case Sample<int> is used.
        Type SampleOfInt = 
            myType.MakeGenericType( typeof(int) );
        // Next get a MethodInfo representing the static generic
        // method GM on type Sample<int>.
        MethodInfo SampleOfIntGM = TypeBuilder.GetMethod(SampleOfInt, 
            genMethod);
        // Next get a MethodInfo for GM<string>, which is the 
        // instantiation of GM that Main calls.
        MethodInfo GMOfString = 
            SampleOfIntGM.MakeGenericMethod( typeof(string) );
        // Finally, emit the call. Push a string onto
        // the stack, as the argument for the generic method.
        ilg.Emit(OpCodes.Ldstr, "Hello, world!");
        ilg.EmitCall(OpCodes.Call, GMOfString, null);
        ilg.Emit(OpCodes.Ret);

        myType.CreateType();
        dummy.CreateType();
        myAssembly.SetEntryPoint(entryPoint);
        myAssembly.Save(myAsmName.Name + ".exe");

        Console.WriteLine(myAsmName.Name + ".exe has been saved.");
    }
}
Imports System.Reflection
Imports System.Reflection.Emit

' Compare the MSIL in this class to the MSIL
' generated by the Reflection.Emit code in class
' Example.
Public Class Sample(Of T)
    Public Field As T
    Public Shared Sub GM(Of U)(ByVal val As U)
        Dim s As New Sample(Of U)
        s.Field = val
        Console.WriteLine(s.Field)
    
    End Sub
End Class 

Public Class Example
    
    Public Shared Sub Main() 
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("TypeBuilderGetFieldExample")
        Dim myAssembly As AssemblyBuilder = _
            myDomain.DefineDynamicAssembly(myAsmName, _
                AssemblyBuilderAccess.Save)
        Dim myModule As ModuleBuilder = _
            myAssembly.DefineDynamicModule(myAsmName.Name, _
                myAsmName.Name & ".exe")
        
        ' Define the sample type.
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Class Or TypeAttributes.Public)
        
        ' Add a type parameter, making the type generic.
        Dim typeParamNames() As String = { "T" }
        Dim typeParams As GenericTypeParameterBuilder() = _
            myType.DefineGenericParameters(typeParamNames)
        
        ' Define a default constructor. Normally it would 
        ' not be necessary to define the default constructor,
        ' but in this case it is needed for the call to
        ' TypeBuilder.GetConstructor, which gets the default
        ' constructor for the generic type constructed from 
        ' Sample(Of T), in the generic method GM(Of U).
        Dim ctor As ConstructorBuilder = _
            myType.DefineDefaultConstructor( _
                MethodAttributes.PrivateScope Or MethodAttributes.Public _
                Or MethodAttributes.HideBySig Or MethodAttributes.SpecialName _
                Or MethodAttributes.RTSpecialName)
        
        ' Add a field of type T, with the name Field.
        Dim myField As FieldBuilder = myType.DefineField( _
            "Field", typeParams(0), FieldAttributes.Public)
        
        ' Add a method and make it generic, with a type 
        ' parameter named U. Note how similar this is to 
        ' the way Sample is turned into a generic type. The
        ' method has no signature, because the type of its
        ' only parameter is U, which is not yet defined.
        Dim genMethod As MethodBuilder = _
            myType.DefineMethod("GM", _
                MethodAttributes.Public Or MethodAttributes.Static)
        Dim methodParamNames() As String = { "U" }
        Dim methodParams As GenericTypeParameterBuilder() = _
            genMethod.DefineGenericParameters(methodParamNames)

        ' Now add a signature for genMethod, specifying U
        ' as the type of the parameter. There is no return value
        ' and no custom modifiers.
        genMethod.SetSignature(Nothing, Nothing, Nothing, _
            New Type() { methodParams(0) }, Nothing, Nothing)
        
        ' Emit a method body for the generic method.
        Dim ilg As ILGenerator = genMethod.GetILGenerator()
        ' Construct the type Sample(Of U) using MakeGenericType.
        Dim SampleOfU As Type = _
            myType.MakeGenericType(methodParams(0))
        ' Create a local variable to store the instance of
        ' Sample(Of U).
        ilg.DeclareLocal(SampleOfU)
        ' Call the default constructor. Note that it is 
        ' necessary to have the default constructor for the
        ' constructed generic type Sample(Of U); use the 
        ' TypeBuilder.GetConstructor method to obtain this 
        ' constructor.
        Dim ctorOfU As ConstructorInfo = _
            TypeBuilder.GetConstructor(SampleOfU, ctor)
        ilg.Emit(OpCodes.Newobj, ctorOfU)
        ' Store the instance in the local variable; load it
        ' again, and load the parameter of genMethod.
        ilg.Emit(OpCodes.Stloc_0)
        ilg.Emit(OpCodes.Ldloc_0)
        ilg.Emit(OpCodes.Ldarg_0)
        ' In order to store the value in the field of the
        ' instance of Sample(Of U), it is necessary to have 
        ' a FieldInfo representing the field of the 
        ' constructed type. Use TypeBuilder.GetField to 
        ' obtain this FieldInfo.
        Dim FieldOfU As FieldInfo = _
            TypeBuilder.GetField(SampleOfU, myField)
        ' Store the value in the field. 
        ilg.Emit(OpCodes.Stfld, FieldOfU)
        ' Load the instance, load the field value, box it
        ' (specifying the type of the type parameter, U), 
        ' and print it.
        ilg.Emit(OpCodes.Ldloc_0)
        ilg.Emit(OpCodes.Ldfld, FieldOfU)
        ilg.Emit(OpCodes.Box, methodParams(0))
        Dim writeLineObj As MethodInfo = _
            GetType(Console).GetMethod("WriteLine", _
                New Type() {GetType(Object)})
        ilg.EmitCall(OpCodes.Call, writeLineObj, Nothing)
        ilg.Emit(OpCodes.Ret)
        
        ' Emit an entry point method; this must be in a
        ' non-generic type.
        Dim dummy As TypeBuilder = _
            myModule.DefineType("Dummy", _
                TypeAttributes.Class Or TypeAttributes.NotPublic)
        Dim entryPoint As MethodBuilder = _
            dummy.DefineMethod("Main", _
                MethodAttributes.Public Or MethodAttributes.Static, _
                Nothing, Nothing)
        ilg = entryPoint.GetILGenerator()
        ' In order to call the static generic method GM, it is
        ' necessary to create a constructed type from the 
        ' generic type definition for Sample. This can be ANY
        ' constructed type; in this case Sample(Of Integer)
        ' is used.
        Dim SampleOfInt As Type = _
            myType.MakeGenericType(GetType(Integer))
        ' Next get a MethodInfo representing the static generic
        ' method GM on type Sample(Of Integer).
        Dim SampleOfIntGM As MethodInfo = _
            TypeBuilder.GetMethod(SampleOfInt, genMethod)
        ' Next get a MethodInfo for GM(Of String), which is the 
        ' instantiation of generic method GM that is called
        ' by Sub Main.
        Dim GMOfString As MethodInfo = _
            SampleOfIntGM.MakeGenericMethod(GetType(String))
        ' Finally, emit the call. Push a string onto
        ' the stack, as the argument for the generic method.
        ilg.Emit(OpCodes.Ldstr, "Hello, world!")
        ilg.EmitCall(OpCodes.Call, GMOfString, Nothing)
        ilg.Emit(OpCodes.Ret)
        
        myType.CreateType()
        dummy.CreateType()
        myAssembly.SetEntryPoint(entryPoint)
        myAssembly.Save(myAsmName.Name & ".exe")
        
        Console.WriteLine(myAsmName.Name & ".exe has been saved.")
    
    End Sub 
End Class 

注釈

GetMethod メソッドは、ジェネリック型定義が TypeBuilder オブジェクトによって表される構築ジェネリック型のメソッドを表す MethodInfo オブジェクトを取得する手段を提供します。The GetMethod method provides a way to get a MethodInfo object that represents a method of a constructed generic type whose generic type definition is represented by a TypeBuilder object.

たとえばC# 、構文の G<T> 型 (Visual Basic ではG(Of T)、でC++は generic <T> ref class G) を表す TypeBuilder オブジェクトがあり、MethodBuilder によって定義されている構文 ( C# T M() ではFunction M() As T C++) のメソッドを表す Visual Basic オブジェクトがあるとします。T M()``G<T>For example, suppose you have a TypeBuilder object that represents the type G<T> in C# syntax (G(Of T) in Visual Basic, generic <T> ref class G in C++) and a MethodBuilder object that represents a method T M() in C# syntax (Function M() As T in Visual Basic, T M() in C++) that is defined by G<T>. G<T> に、構築された G<U> 型のインスタンスを作成し、そのインスタンスでメソッド M を呼び出す型パラメーター U を持つジェネリックメソッドがあるとします。Suppose that G<T> has a generic method with type parameter U that creates an instance of the constructed type G<U> and calls method M on that instance. 関数呼び出しを出力するには、構築された型の M を表す MethodInfo オブジェクトが必要です。つまり、型 Tではなく型 U を返します。In order to emit the function call, you need a MethodInfo object that represents M on the constructed type - in other words, that returns type U rather than type T. これを行うには、まず、TypeBuilder オブジェクトの MakeGenericType メソッドを呼び出して、型引数として U を表す GenericTypeParameterBuilder オブジェクトを指定します。To do this, first call the MakeGenericType method on the TypeBuilder object, specifying the GenericTypeParameterBuilder object that represents U as the type argument. 次に、パラメーター type として MakeGenericType メソッドの戻り値を、パラメーター T M() として methodを表す MethodBuilder オブジェクトを使用して、GetMethod メソッドを呼び出します。Then call the GetMethod method with the return value of the MakeGenericType method as parameter type and the MethodBuilder object that represents T M() as parameter method. 戻り値は、関数呼び出しを生成するために必要な MethodInfo オブジェクトです。The return value is the MethodInfo object you need to emit the function call. このコード例は、このようなシナリオを示しています。The code example demonstrates a scenario similar to this.

適用対象