ILGenerator.EmitCalli Metodo

Definizione

Spazio dei nomi:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Inserisce un'istruzione Calli nel flusso MSIL (Microsoft Intermediate Language).

Overload

EmitCalli(OpCode, CallingConvention, Type, Type[])	Inserisce un'istruzione Calli nel flusso di istruzioni MSIL (Microsoft Intermediate Language), specificando una convenzione di chiamata non gestita per la chiamata indiretta.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Inserisce un'istruzione Calli nel flusso di istruzioni MSIL (Microsoft Intermediate Language), specificando una convenzione di chiamata gestita per la chiamata indiretta.

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

Origine:

ILGenerator.cs

Inserisce un'istruzione Calli nel flusso di istruzioni MSIL (Microsoft Intermediate Language), specificando una convenzione di chiamata non gestita per la chiamata indiretta.

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

Parametri

opcode

OpCode

Istruzione MSIL da emettere nel flusso. Deve essere Calli.

unmanagedCallConv

CallingConvention

Convenzione di chiamata non gestita da utilizzare.

returnType

Type

Oggetto Type del risultato.

parameterTypes

Type[]

Tipi di argomenti necessari per l'istruzione.

Esempio

Nell'esempio di codice seguente viene illustrato l'utilizzo contestuale del EmitCalli metodo per chiamare un metodo di tipo non gestito esterno alla classe dinamica.

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

Commenti

Usare EmitCalli per inserire un'istruzione Calli nel flusso. Non usare Emit.

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

Origine:

ILGenerator.cs

Inserisce un'istruzione Calli nel flusso di istruzioni MSIL (Microsoft Intermediate Language), specificando una convenzione di chiamata gestita per la chiamata indiretta.

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

Parametri

opcode

OpCode

Istruzione MSIL da emettere nel flusso. Deve essere Calli.

callingConvention

CallingConventions

Convenzione di chiamata gestita da utilizzare.

returnType

Type

Oggetto Type del risultato.

parameterTypes

Type[]

Tipi di argomenti necessari per l'istruzione.

optionalParameterTypes

Type[]

Tipi di argomenti facoltativi per le chiamate a varargs.

Eccezioni

InvalidOperationException

optionalParameterTypes non è null, ma callingConvention non include il flag VarArgs.

Commenti

Usare EmitCalli per inserire un'istruzione Calli nel flusso. Non usare Emit.

Se optionalParameterTypes specifica argomenti facoltativi, callingConvention deve includere il CallingConventions.VarArgs flag .