ILGenerator.EmitCalli Metode

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

System.Reflection.Emit.ILGeneration.dll

Calli Menempatkan instruksi ke aliran bahasa perantara Microsoft (MSIL).

Overload

EmitCalli(OpCode, CallingConvention, Type, Type[])	Calli Menempatkan instruksi ke aliran bahasa perantara Microsoft (MSIL), menentukan konvensi panggilan tidak terkelola untuk panggilan tidak langsung.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Calli Menempatkan instruksi ke aliran bahasa perantara Microsoft (MSIL), menentukan konvensi panggilan terkelola untuk panggilan tidak langsung.

EmitCalli(OpCode, CallingConvention, Type, Type[])

Sumber:

ILGenerator.cs

Calli Menempatkan instruksi ke aliran bahasa perantara Microsoft (MSIL), menentukan konvensi panggilan tidak terkelola untuk panggilan tidak langsung.

public:
 abstract void EmitCalli(System::Reflection::Emit::OpCode opcode, System::Runtime::InteropServices::CallingConvention unmanagedCallConv, Type ^ returnType, cli::array <Type ^> ^ parameterTypes);

public abstract void EmitCalli (System.Reflection.Emit.OpCode opcode, System.Runtime.InteropServices.CallingConvention unmanagedCallConv, Type? returnType, Type[]? parameterTypes);

abstract member EmitCalli : System.Reflection.Emit.OpCode * System.Runtime.InteropServices.CallingConvention * Type * Type[] -> unit

Public MustOverride Sub EmitCalli (opcode As OpCode, unmanagedCallConv As CallingConvention, returnType As Type, parameterTypes As Type())

Parameter

opcode

OpCode

Instruksi MSIL yang akan dipancarkan ke aliran. Harus berupa Calli.

unmanagedCallConv

CallingConvention

Konvensi panggilan tidak terkelola yang akan digunakan.

returnType

Type

Dari Type hasilnya.

parameterTypes

Type[]

Jenis argumen yang diperlukan untuk instruksi.

Contoh

Sampel kode berikut menunjukkan penggunaan EmitCalli kontekstual metode untuk memanggil metode jenis yang tidak dikelola di luar kelas dinamis.

MethodBuilder^ myMthdBuilder = myTypeBuilder->DefineMethod( "MyMethod",
                               MethodAttributes::Public,
                               returnType, mthdParamTypes );

// We will assume that an external unmanaged type "LegacyNumber" has been loaded, and
// that it has a method "ToString" which returns a String.

MethodInfo^ unmanagedMthdMI = Type::GetType( "LegacyNumber" )->GetMethod( "ToString" );
ILGenerator^ myMthdIL = myMthdBuilder->GetILGenerator();

// Code to emit various IL opcodes here ...

// Load a reference to the specific Object instance onto the stack.

myMthdIL->Emit( OpCodes::Ldc_I4, addrOfLegacyNumberObject );
myMthdIL->Emit( OpCodes::Ldobj, Type::GetType( "LegacyNumber" ) );

// Make the call to the unmanaged type method, telling it that the method is
// the member of a specific instance, to expect a String
// as a return value, and that there are no explicit parameters.
myMthdIL->EmitCalli( OpCodes::Calli,
                     System::Runtime::InteropServices::CallingConvention::ThisCall,
                     String::typeid,
                     gcnew array<Type^>( 0 ) );

// More IL code emission here ...

MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("MyMethod",
                  MethodAttributes.Public,
                  returnType, mthdParamTypes);
                            
// We will assume that an external unmanaged type "LegacyNumber" has been loaded, and
// that it has a method "ToString" which returns a string.

MethodInfo unmanagedMthdMI = Type.GetType("LegacyNumber").GetMethod("ToString");
ILGenerator myMthdIL = myMthdBuilder.GetILGenerator();

// Code to emit various IL opcodes here ...

// Load a reference to the specific object instance onto the stack.

myMthdIL.Emit(OpCodes.Ldc_I4, addrOfLegacyNumberObject);
myMthdIL.Emit(OpCodes.Ldobj, Type.GetType("LegacyNumber"));

// Make the call to the unmanaged type method, telling it that the method is
// the member of a specific instance, to expect a string
// as a return value, and that there are no explicit parameters.
myMthdIL.EmitCalli(OpCodes.Calli,
           System.Runtime.InteropServices.CallingConvention.ThisCall,
               typeof(string),
           new Type[] {});

// More IL code emission here ...

    Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("MyMethod", _
                    MethodAttributes.Public, _
                    returnType, mthdParamTypes)
  
    ' We will assume that an external unmanaged type "LegacyNumber" has been loaded, and
    ' that it has a method "ToString" which returns a string.

    Dim unmanagedMthdMI As MethodInfo = Type.GetType("LegacyNumber").GetMethod("ToString")
    Dim myMthdIL As ILGenerator = myMthdBuilder.GetILGenerator()
  
    ' Code to emit various IL opcodes here ...
    ' Load a reference to the specific object instance onto the stack.

    myMthdIL.Emit(OpCodes.Ldc_I4, addrOfLegacyNumberObject)
    myMthdIL.Emit(OpCodes.Ldobj, Type.GetType("LegacyNumber"))
  
    ' Make the call to the unmanaged type method, telling it that the method is
    ' the member of a specific instance, to expect a string 
    ' as a return value, and that there are no explicit parameters.

    myMthdIL.EmitCalli(OpCodes.Calli, System.Runtime.InteropServices.CallingConvention.ThisCall, _
                  GetType(String), New Type() {})

' More IL code emission here ...

Keterangan

Gunakan EmitCalli untuk menempatkan Calli instruksi ke aliran. Jangan gunakan Emit.

EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])

Sumber:

ILGenerator.cs

Calli Menempatkan instruksi ke aliran bahasa perantara Microsoft (MSIL), menentukan konvensi panggilan terkelola untuk panggilan tidak langsung.

public:
 abstract void EmitCalli(System::Reflection::Emit::OpCode opcode, System::Reflection::CallingConventions callingConvention, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, cli::array <Type ^> ^ optionalParameterTypes);

public abstract void EmitCalli (System.Reflection.Emit.OpCode opcode, System.Reflection.CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, Type[]? optionalParameterTypes);

abstract member EmitCalli : System.Reflection.Emit.OpCode * System.Reflection.CallingConventions * Type * Type[] * Type[] -> unit

Public MustOverride Sub EmitCalli (opcode As OpCode, callingConvention As CallingConventions, returnType As Type, parameterTypes As Type(), optionalParameterTypes As Type())

Parameter

opcode

OpCode

Instruksi MSIL yang akan dipancarkan ke aliran. Harus berupa Calli.

callingConvention

CallingConventions

Konvensi panggilan terkelola yang akan digunakan.

returnType

Type

Dari Type hasilnya.

parameterTypes

Type[]

Jenis argumen yang diperlukan untuk instruksi.

optionalParameterTypes

Type[]

Jenis argumen opsional untuk varargs panggilan.

Pengecualian

InvalidOperationException

optionalParameterTypes bukan null, tetapi callingConvention tidak menyertakan VarArgs bendera .

Keterangan

Gunakan EmitCalli untuk menempatkan Calli instruksi ke aliran. Jangan gunakan Emit.

Jika optionalParameterTypes menentukan argumen opsional, callingConvention harus menyertakan CallingConventions.VarArgs bendera .