ILGenerator.EmitCalli Método

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

System.Reflection.Emit.ILGeneration.dll

Coloca una instrucción Calli en la secuencia del Lenguaje intermedio de Microsoft (MSIL).

Sobrecargas

EmitCalli(OpCode, CallingConvention, Type, Type[])	Coloca una instrucción máquina Calli en la secuencia del Lenguaje intermedio de Microsoft (MSIL), especificando una convención de llamada no administrada para la llamada indirecta.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Coloca una instrucción máquina Calli en la secuencia del Lenguaje intermedio de Microsoft (MSIL), especificando una convención de llamada administrada para la llamada indirecta.

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

Source:

ILGenerator.cs

Coloca una instrucción máquina Calli en la secuencia del Lenguaje intermedio de Microsoft (MSIL), especificando una convención de llamada no administrada para la llamada indirecta.

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

La instrucción MSIL que se emiten en la secuencia. Debe ser Calli.

unmanagedCallConv

CallingConvention

Convención de llamada no administrada que se va a utilizar.

returnType

Type

Type del resultado.

parameterTypes

Type[]

Tipos de los argumentos requeridos de la instrucción máquina.

Ejemplos

En el ejemplo de código siguiente se muestra el uso contextual del EmitCalli método para llamar a un método de tipo no administrado externo a la clase 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 ...

Comentarios

Use EmitCalli para colocar una Calli instrucción en la secuencia. No use Emit.

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

Source:

ILGenerator.cs

Coloca una instrucción máquina Calli en la secuencia del Lenguaje intermedio de Microsoft (MSIL), especificando una convención de llamada administrada para la llamada indirecta.

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

La instrucción MSIL que se emiten en la secuencia. Debe ser Calli.

callingConvention

CallingConventions

Convención de llamada administrada que se va a utilizar.

returnType

Type

Type del resultado.

parameterTypes

Type[]

Tipos de los argumentos requeridos de la instrucción máquina.

optionalParameterTypes

Type[]

Tipos de los argumentos opcionales para las llamadas varargs.

Excepciones

InvalidOperationException

optionalParameterTypes no es null, pero callingConvention no incluye el marcador VarArgs.

Comentarios

Use EmitCalli para colocar una Calli instrucción en la secuencia. No use Emit.

Si optionalParameterTypes especifica argumentos opcionales, callingConvention debe incluir la CallingConventions.VarArgs marca .