ILGenerator.EmitCalli Methode

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Fügt eine Calli-Anweisung in den MSIL-Stream (Microsoft Intermediate Language) ein.

Überlädt

EmitCalli(OpCode, CallingConvention, Type, Type[])	Fügt eine Calli-Anweisung in den MSIL-Stream (Microsoft Intermediate Language) ein, die eine nicht verwaltete Aufrufkonvention für den indirekten Aufruf angibt.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Fügt eine Calli-Anweisung in den MSIL-Stream (Microsoft Intermediate Language) ein, die eine verwaltete Aufrufkonvention für den indirekten Aufruf angibt.

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

Quelle:

ILGenerator.cs

Fügt eine Calli-Anweisung in den MSIL-Stream (Microsoft Intermediate Language) ein, die eine nicht verwaltete Aufrufkonvention für den indirekten Aufruf angibt.

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

Parameter

opcode

OpCode

Die MSIL-Anweisung, die in den Datenstrom ausgegeben werden soll. Muss Callilauten.

unmanagedCallConv

CallingConvention

Die zu verwendende nicht verwaltete Aufrufkonvention.

returnType

Type

Der Type des Ergebnisses.

parameterTypes

Type[]

Die Typen der für die Anweisung erforderlichen Argumente.

Beispiele

Im folgenden Codebeispiel wird die kontextbezogene Verwendung der EmitCalli -Methode veranschaulicht, um eine nicht verwaltete Typmethode außerhalb der dynamischen Klasse aufzurufen.

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

Hinweise

Verwenden Sie EmitCalli , um eine Calli Anweisung im Stream zu platzieren. Verwenden Sie nicht Emit.

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

Quelle:

ILGenerator.cs

Fügt eine Calli-Anweisung in den MSIL-Stream (Microsoft Intermediate Language) ein, die eine verwaltete Aufrufkonvention für den indirekten Aufruf angibt.

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

Parameter

opcode

OpCode

Die MSIL-Anweisung, die in den Datenstrom ausgegeben werden soll. Muss Callilauten.

callingConvention

CallingConventions

Die zu verwendende verwaltete Aufrufkonvention.

returnType

Type

Der Type des Ergebnisses.

parameterTypes

Type[]

Die Typen der für die Anweisung erforderlichen Argumente.

optionalParameterTypes

Type[]

Die Typen der optionalen Argumente für varargs-Aufrufe.

Ausnahmen

InvalidOperationException

optionalParameterTypes ist null, aber callingConvention schließt das VarArgs-Flag nicht ein.

Hinweise

Verwenden Sie EmitCalli , um eine Calli Anweisung im Stream zu platzieren. Verwenden Sie nicht Emit.

Wenn optionalParameterTypes optionale Argumente angibt, callingConvention muss das CallingConventions.VarArgs Flag enthalten sein.