MethodBuilder.SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][]) MethodBuilder.SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][]) MethodBuilder.SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][]) MethodBuilder.SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][]) Method

定義

戻り値の型、パラメーターの型、戻り値の型とパラメーターの型の必須およびオプションのカスタム修飾子を含むメソッド シグネチャを設定します。Sets the method signature, including the return type, the parameter types, and the required and optional custom modifiers of the return type and parameter types.

public:
 void SetSignature(Type ^ returnType, cli::array <Type ^> ^ returnTypeRequiredCustomModifiers, cli::array <Type ^> ^ returnTypeOptionalCustomModifiers, cli::array <Type ^> ^ parameterTypes, cli::array <cli::array <Type ^> ^> ^ parameterTypeRequiredCustomModifiers, cli::array <cli::array <Type ^> ^> ^ parameterTypeOptionalCustomModifiers);
public void SetSignature (Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers);
member this.SetSignature : Type * Type[] * Type[] * Type[] * Type[][] * Type[][] -> unit
Public Sub SetSignature (returnType As Type, returnTypeRequiredCustomModifiers As Type(), returnTypeOptionalCustomModifiers As Type(), parameterTypes As Type(), parameterTypeRequiredCustomModifiers As Type()(), parameterTypeOptionalCustomModifiers As Type()())

パラメーター

returnType
Type Type Type Type

メソッドの戻り値の型。The return type of the method.

returnTypeRequiredCustomModifiers
Type[]

メソッドの戻り値の型の IsConst など、必須のカスタム修飾子を表す型の配列。An array of types representing the required custom modifiers, such as IsConst, for the return type of the method. 戻り値の型が必須のカスタム修飾子を持たない場合は、null を指定します。If the return type has no required custom modifiers, specify null.

returnTypeOptionalCustomModifiers
Type[]

メソッドの戻り値の型の IsConst のような、省略可能なカスタム修飾子を表す型の配列。An array of types representing the optional custom modifiers, such as IsConst, for the return type of the method. 戻り値の型に省略可能のカスタム修飾子がない場合は、null を指定します。If the return type has no optional custom modifiers, specify null.

parameterTypes
Type[]

メソッドのパラメーターの型。The types of the parameters of the method.

parameterTypeRequiredCustomModifiers
Type[][]

型の配列の配列。An array of arrays of types. 型の各配列は、IsConst のような、対応するパラメーターの必須のカスタム修飾子を表します。Each array of types represents the required custom modifiers for the corresponding parameter, such as IsConst. 特定のパラメーターに必須のカスタム修飾子がない場合は、型の配列の代わりに null を指定します。If a particular parameter has no required custom modifiers, specify null instead of an array of types. どのパラメーターにも必須のカスタム修飾子がない場合は、配列の配列の代わりに null を指定します。If none of the parameters have required custom modifiers, specify null instead of an array of arrays.

parameterTypeOptionalCustomModifiers
Type[][]

型の配列の配列。An array of arrays of types. 型の各配列は、 IsConstのような、対応するパラメーターの省略可能なカスタム修飾子を表します。Each array of types represents the optional custom modifiers for the corresponding parameter, such as IsConst. 特定のパラメーターに省略可能なカスタム修飾子がない場合は、型の配列の代わりに null を指定します。If a particular parameter has no optional custom modifiers, specify null instead of an array of types. どのパラメーターにも省略可能なカスタム修飾子がない場合は、配列の配列の代わりに null を指定します。If none of the parameters have optional custom modifiers, specify null instead of an array of arrays.

例外

現在のメソッドはジェネリック メソッドですが、ジェネリック メソッドの定義ではありません。The current method is generic, but is not a generic method definition. つまり、IsGenericMethod プロパティは true ですが、IsGenericMethodDefinition プロパティが false です。That is, the IsGenericMethod property is true, but the IsGenericMethodDefinition property is false.

次のコード例には、type パラメーター Tを持つ、Sample という名前のジェネリッククラスのソースコードが含まれています。The following code example contains source code for a generic class named Sample that has a type parameter T. クラスにはField、型Tのフィールドと、独自の型パラメーターをGM U持つジェネリックメソッドがあります。The class has a field named Field, of type T, and a generic method GM with its own type parameter, 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のコードは、ジェネリックコードを出力SetSignatureするときにメソッドを使用する方法を示しています。The code in class Example demonstrates the use of the SetSignature method in emitting generic code. クラスMain Sample Tのメソッドは、とTypeBuilder.DefineGenericParametersいう名前のクラスを含む動的アセンブリを作成し、メソッドを使用して、という名前の型パラメーターを追加することによって、ジェネリックにします。 ExampleThe Main method of class Example creates a dynamic assembly containing a class named Sample, and uses the TypeBuilder.DefineGenericParameters method to make it generic by adding a type parameter named T. パラメーターなしのコンストラクターと、型Field Tのという名前のフィールドがクラスSampleに追加されます。A parameterless constructor and a field named Field, of type T, are added to class Sample. メソッドが追加され、 DefineGenericParametersメソッドを使用してジェネリックメソッドに変換されます。 GMA method GM is added, and turned into a generic method using the DefineGenericParameters method. GM型パラメーターにはとUいう名前が付けられます。The type parameter of GM is named U. 型パラメーターを定義すると、 GM SetSignatureメソッドを使用してのシグネチャが追加されます。Once the type parameter is defined, the signature of GM is added, using the SetSignature method. 戻り値の型はなく、必須またはカスタムの修飾子もありません。このため、 nullこのparameterTypesメソッドのすべてのパラメーターは、メソッドの唯一のパラメーターの型を設定する以外は、メソッドの型Uパラメーターに設定されます。There is no return type, and no required or custom modifiers, so all the parameters of this method are null except parameterTypes, which sets the type of the only parameter of the method; this is set to the method's type parameter, U. メソッドの本体は、構築Sample<U>された型のインスタンス (Sample(Of U) Visual Basic) を作成し、メソッドのパラメーターをに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の本体では、静的String Sample<int> GMメソッドは構築されたジェネリック型 (Sample(Of Integer) Visual Basic) で呼び出され、型はにU置き換えられます。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. Sample<U> GM MethodInfo MethodInfoメソッドは、構築されたジェネリック型MethodInfo.MakeGenericMethodの静的メソッドのを作成するために使用されます。メソッドを使用して、メソッド呼び出しで出力できるを作成します。 TypeBuilder.GetMethodThe TypeBuilder.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 

注釈

メソッドが定義されているときに戻り値の型およびパラメーターの数と型がわかっている場合は、パラメーターの型TypeBuilder.DefineMethodの配列を受け取るメソッドのオーバーロードを使用して設定できます。If the return type and the number and types of the parameters are known when the method is defined, they can be established using any overload of the TypeBuilder.DefineMethod method that accepts an array of parameter types. ただし、ジェネリックメソッドには、その型が1つ以上の独自のジェネリック型パラメーターによって指定されているパラメーターを含めることができます。このパラメーターは、メソッドが定義されるまで定義できません。However, a generic method can have parameters whose types are specified by one or more of its own generic type parameters, which cannot be defined until after the method has been defined. この場合は、このメソッドを使用して、パラメーターの型を設定します。Use this method to set the parameter types in that case.

戻り値の型とパラメーターの型のどちらにも省略可能なまたは必須IsConstModifierのカスタム修飾子 (などSetReturnType ) SetParametersがない場合は、メソッドとメソッドを使用できます。If neither the return type nor the parameter types have optional or required custom modifiers, such as IsConstModifier, you can use the SetReturnType and SetParameters methods.

このメソッドを呼び出すと、 TypeBuilder.DefineMethodメソッドを使用して確立されたパラメーターと戻り値の型が置き換えられます。Calling this method replaces the parameters and return type established using the TypeBuilder.DefineMethod method.

適用対象

こちらもご覧ください