ILGenerator.EmitCalli Método

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Coloca uma instrução Calli no fluxo do MSIL (Microsoft Intermediate Language).

Sobrecargas

EmitCalli(OpCode, CallingConvention, Type, Type[])	Coloca uma instrução Calli no fluxo da MSIL (Microsoft Intermediate Language), especificando uma convenção de chamada não gerenciada para a chamada indireta.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Coloca uma instrução Calli no fluxo da MSIL (Microsoft Intermediate Language), especificando uma convenção de chamada gerenciada para a chamada indireta.

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

Origem:

ILGenerator.cs

Coloca uma instrução Calli no fluxo da MSIL (Microsoft Intermediate Language), especificando uma convenção de chamada não gerenciada para a chamada indireta.

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())

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo. Deve ser Calli.

unmanagedCallConv

CallingConvention

A convenção de chamada não gerenciada a ser usada.

returnType

Type

O Type do resultado.

parameterTypes

Type[]

Os tipos dos argumentos necessários para a instrução.

Exemplos

O exemplo de código a seguir demonstra o uso contextual do EmitCalli método para chamar um método de tipo não gerenciado externo à classe dinâmica.

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 ...

Comentários

Use EmitCalli para colocar uma Calli instrução no fluxo. Não use Emit.

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

Origem:

ILGenerator.cs

Coloca uma instrução Calli no fluxo da MSIL (Microsoft Intermediate Language), especificando uma convenção de chamada gerenciada para a chamada indireta.

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())

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo. Deve ser Calli.

callingConvention

CallingConventions

A convenção de chamada gerenciada a ser usada.

returnType

Type

O Type do resultado.

parameterTypes

Type[]

Os tipos dos argumentos necessários para a instrução.

optionalParameterTypes

Type[]

Os tipos de argumentos opcionais para chamadas varargs.

Exceções

InvalidOperationException

optionalParameterTypes não é null, mas callingConvention não inclui o sinalizador VarArgs.

Comentários

Use EmitCalli para colocar uma Calli instrução no fluxo. Não use Emit.

Se optionalParameterTypes especificar argumentos opcionais, callingConvention deverá incluir o CallingConventions.VarArgs sinalizador.