ILGenerator.EmitCalli Metoda

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

System.Reflection.Emit.ILGeneration.dll

Vloží instrukce do datového Calli proudu jazyka MSIL (Microsoft Intermediate Language).

Přetížení

EmitCalli(OpCode, CallingConvention, Type, Type[])	Calli Vloží instrukci do datového proudu jazyka MSIL (Microsoft Intermediate Language) a určí nespravovanou konvenci volání pro nepřímé volání.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Calli Vloží instrukce do datového proudu jazyka MSIL (Microsoft Intermediate Language) a určí pro nepřímé volání spravovanou konvenci volání.

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

Zdroj:

ILGenerator.cs

Calli Vloží instrukci do datového proudu jazyka MSIL (Microsoft Intermediate Language) a určí nespravovanou konvenci volání pro nepřímé volání.

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

Parametry

opcode

OpCode

Instrukce jazyka MSIL, která se má vysílovat do datového proudu. Musí být Calli.

unmanagedCallConv

CallingConvention

Nespravovaná konvence volání, která se má použít.

returnType

Type

Hodnota Type výsledku.

parameterTypes

Type[]

Typy požadovaných argumentů instrukce.

Příklady

Následující ukázka kódu ukazuje kontextové použití EmitCalli metody k volání nespravované metody typu mimo dynamickou třídu.

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

Poznámky

Slouží EmitCalli k vložení Calli instrukce do datového proudu. Nepoužívejte .Emit

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

Zdroj:

ILGenerator.cs

Calli Vloží instrukce do datového proudu jazyka MSIL (Microsoft Intermediate Language) a určí pro nepřímé volání spravovanou konvenci volání.

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

Parametry

opcode

OpCode

Instrukce jazyka MSIL, která se má vysílovat do datového proudu. Musí být Calli.

callingConvention

CallingConventions

Spravovaná konvence volání, která se má použít.

returnType

Type

Hodnota Type výsledku.

parameterTypes

Type[]

Typy požadovaných argumentů instrukce.

optionalParameterTypes

Type[]

Typy volitelných argumentů pro varargs volání.

Výjimky

InvalidOperationException

optionalParameterTypes není null, ale callingConvention neobsahuje VarArgs příznak .

Poznámky

Slouží EmitCalli k vložení Calli instrukce do datového proudu. Nepoužívejte .Emit

Pokud optionalParameterTypes určuje volitelné argumenty, callingConvention musí obsahovat CallingConventions.VarArgs příznak .