ILGenerator.EmitCalli Méthode

Définition

Espace de noms:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Place une instruction Calli dans le flux MSIL (Microsoft Intermediate Language).

Surcharges

EmitCalli(OpCode, CallingConvention, Type, Type[])	Place une instruction Calli dans le flux MSIL en spécifiant une convention d'appel non managée pour l'appel indirect.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Place une instruction Calli dans le flux MSIL en spécifiant une convention d'appel managée pour l'appel indirect.

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

Source:

ILGenerator.cs

Place une instruction Calli dans le flux MSIL en spécifiant une convention d'appel non managée pour l'appel indirect.

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

Paramètres

opcode

OpCode

Instruction MSIL à émettre dans le flux. Doit être Calli.

unmanagedCallConv

CallingConvention

Convention d'appel non managée à utiliser.

returnType

Type

Type du résultat.

parameterTypes

Type[]

Types des arguments requis pour l'instruction.

Exemples

L’exemple de code suivant illustre l’utilisation contextuelle de la EmitCalli méthode pour appeler une méthode de type non managée externe à la classe dynamique.

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

Remarques

Utilisez EmitCalli pour placer une Calli instruction dans le flux. N’utilisez pas Emit.

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

Source:

ILGenerator.cs

Place une instruction Calli dans le flux MSIL en spécifiant une convention d'appel managée pour l'appel indirect.

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

Paramètres

opcode

OpCode

Instruction MSIL à émettre dans le flux. Doit être Calli.

callingConvention

CallingConventions

Convention d'appel managée à utiliser.

returnType

Type

Type du résultat.

parameterTypes

Type[]

Types des arguments requis pour l'instruction.

optionalParameterTypes

Type[]

Types des arguments facultatifs pour les appels varargs.

Exceptions

InvalidOperationException

optionalParameterTypes n'est pas null, mais callingConvention ne comprend pas l'indicateur VarArgs.

Remarques

Utilisez EmitCalli pour placer une Calli instruction dans le flux. N’utilisez pas Emit.

Si optionalParameterTypes spécifie des arguments facultatifs, callingConvention doit inclure l’indicateur CallingConventions.VarArgs .