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

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

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

MethodBuilder.SetSignature メソッド

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

戻り値の型、パラメータの型、戻り値の型とパラメータの型の必須およびオプションのカスタム修飾子を含むメソッドシグネチャを設定します。

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

Visual Basic (宣言)

Public Sub SetSignature ( _
    returnType As Type, _
    returnTypeRequiredCustomModifiers As Type(), _
    returnTypeOptionalCustomModifiers As Type(), _
    parameterTypes As Type(), _
    parameterTypeRequiredCustomModifiers As Type()(), _
    parameterTypeOptionalCustomModifiers As Type()() _
)

Visual Basic (使用法)

Dim instance As MethodBuilder
Dim returnType As Type
Dim returnTypeRequiredCustomModifiers As Type()
Dim returnTypeOptionalCustomModifiers As Type()
Dim parameterTypes As Type()
Dim parameterTypeRequiredCustomModifiers As
 Type()()
Dim parameterTypeOptionalCustomModifiers As
 Type()()

instance.SetSignature(returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers,
 parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers)

public void SetSignature (
    Type returnType,
    Type[] returnTypeRequiredCustomModifiers,
    Type[] returnTypeOptionalCustomModifiers,
    Type[] parameterTypes,
    Type[][] parameterTypeRequiredCustomModifiers,
    Type[][] parameterTypeOptionalCustomModifiers
)

C++

public:
void SetSignature (
    Type^ returnType, 
    array<Type^>^ returnTypeRequiredCustomModifiers, 
    array<Type^>^ returnTypeOptionalCustomModifiers, 
    array<Type^>^ parameterTypes, 
    array<array<Type^>^>^ parameterTypeRequiredCustomModifiers, 
    array<array<Type^>^>^ parameterTypeOptionalCustomModifiers
)

public void SetSignature (
    Type returnType, 
    Type[] returnTypeRequiredCustomModifiers, 
    Type[] returnTypeOptionalCustomModifiers, 
    Type[] parameterTypes, 
    Type[][] parameterTypeRequiredCustomModifiers, 
    Type[][] parameterTypeOptionalCustomModifiers
)

JScript

public function SetSignature (
    returnType : Type, 
    returnTypeRequiredCustomModifiers : Type[], 
    returnTypeOptionalCustomModifiers : Type[], 
    parameterTypes : Type[], 
    parameterTypeRequiredCustomModifiers : Type[][], 
    parameterTypeOptionalCustomModifiers : Type[][]
)

パラメータ

returnType: メソッドの戻り値の型。

returnTypeRequiredCustomModifiers: メソッドの戻り値の型の必須のカスタム修飾子 (IsConst など) を表す型の配列。戻り値の型に必須のカスタム修飾子がない場合は、null 参照 (Visual Basic では Nothing) を指定します。

returnTypeOptionalCustomModifiers: メソッドの戻り値の型のオプションのカスタム修飾子 (IsConst など) を表す型の配列。戻り値の型に必須のカスタム修飾子がない場合は、null 参照 (Visual Basic では Nothing) を指定します。

parameterTypes: メソッドのパラメータの型。

parameterTypeRequiredCustomModifiers: 型の配列の配列。型の各配列は、対応するパラメータの必須のカスタム修飾子 (IsConst など) を表します。特定のパラメータに必須のカスタム修飾子がない場合は、型の配列の代わりに null 参照 (Visual Basic では Nothing) を指定します。必須のカスタム修飾子を持つパラメータがない場合は、配列の配列の代わりに null 参照 (Visual Basic では Nothing) を指定します。

parameterTypeOptionalCustomModifiers: 型の配列の配列。型の各配列は、対応するパラメータのオプションのカスタム修飾子 (IsConst など) を表します。特定のパラメータにオプションのカスタム修飾子がない場合は、型の配列の代わりに null 参照 (Visual Basic では Nothing) を指定します。オプションのカスタム修飾子を持つパラメータがない場合は、配列の配列の代わりに null 参照 (Visual Basic では Nothing) を指定します。

例外

例外の種類	条件
InvalidOperationException	現在のメソッドはジェネリックメソッドですが、ジェネリックメソッドの定義ではありません。つまり、IsGenericMethod プロパティは true ですが、IsGenericMethodDefinition プロパティが false です。

解説

メソッドを定義するときに、戻り値の型およびパラメータの数と型がわからない場合は、パラメータの型の配列を受け入れる System.Reflection.Emit.TypeBuilder.DefineMethod メソッドの任意のオーバーロードを使用してこれらを設定できます。ただし、ジェネリックメソッドは、1 つ以上の独自のジェネリック型パラメータで型が指定されたパラメータを持つことができます。これらのパラメータは、メソッドが定義されるまで定義できません。その場合は、このメソッドを使用してパラメータの型を設定します。

戻り値の型とパラメータの型のいずれにも、IsConstModifier などのオプションまたは必須のカスタム修飾子がない場合は、SetReturnType メソッドと SetParameters メソッドを使用できます。

このメソッドを呼び出すと、System.Reflection.Emit.TypeBuilder.DefineMethod メソッドを使用して設定されたパラメータと戻り値の型が置き換えられます。

使用例

型パラメータ T を持つ、Sample という名前のジェネリッククラスのソースコードを含むコード例を次に示します。このクラスは、Field という名前のフィールドを持つ T 型のクラスです。また、独自の型パラメータ U を持つジェネリックメソッド GM が含まれています。GM メソッドは、Sample の型パラメータを独自の型パラメータ U に置き換えて、Sample のインスタンスを作成し、入力パラメータを Field に格納します。このソースコードはコンパイルされますが、使用されません。MSIL 逆アセンブラ (Ildasm.exe) を使用してソースコードを表示し、Example クラスで出力されたコードと比較できます。

ジェネリックコードの出力時に、SetSignature メソッドを使用する Example クラスのコードを示します。Example クラスの Main メソッドは、Sample という名前のクラスを格納する動的アセンブリを作成し、TypeBuilder.DefineGenericParameters メソッドを使用して、T という名前の型パラメータを追加し、これをジェネリックにします。既定のコンストラクタと Field という名前の T 型のフィールドが、Sample クラスに追加されます。DefineGenericParameters メソッドを使用して、GM メソッドが追加され、ジェネリックメソッドに変更されます。GM の型パラメータには、U という名前が付けられています。型パラメータが定義されると、SetSignature メソッドを使用して、GM のシグネチャが追加されます。戻り値の型はなく、必須の修飾子やカスタム修飾子も存在しないため、メソッドの唯一のパラメータの型を設定する parameterTypes を除き、このメソッドのすべてのパラメータは null 参照 (Visual Basic では Nothing) です。メソッドのパラメータの型は、メソッドの型パラメータである U に設定されます。メソッドの本体は、構築された型 Sample<U> (Visual Basic では Sample(Of U)) のインスタンスを作成し、メソッドのパラメータを Field に割り当てた後、Field の値を出力します。エントリポイントである Main メソッドを保持するために、ダミー型が定義されます。Main の本体では、U を String 型に置き換えて、構築ジェネリック型 Sample<int> (Visual Basic では Sample(Of Integer)) で静的メソッド GM が呼び出されます。TypeBuilder.GetMethod メソッドを使用して、構築ジェネリック型 Sample<U> の静的メソッド GM の MethodInfo を作成します。次に、MethodInfo.MakeGenericMethod メソッドを使用して、メソッド呼び出しで出力できる MethodInfo を作成します。

このコード例を実行すると、出力されたアセンブリは TypeBuilderGetFieldExample.exe として保存されます。この TypeBuilderGetFieldExample.exe を実行できます。また、MSIL 逆アセンブラ (Ildasm.exe) を使用すると、出力したコードをこのコード例自体にコンパイルされる Sample クラスのコードと比較できます。

Visual Basic

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

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.");
    }
}