ILGenerator.EmitCalli Metoda

Definicja

Przestrzeń nazw:

System.Reflection.Emit

Zestaw:

System.Reflection.Emit.ILGeneration.dll

Umieszcza instrukcję Calli na strumieniu języka pośredniego firmy Microsoft (MSIL).

Przeciążenia

EmitCalli(OpCode, CallingConvention, Type, Type[])	Umieszcza instrukcję Calli w strumieniu języka microsoft intermediate language (MSIL), określając niezarządzaną konwencję wywoływania dla wywołania pośredniego.
EmitCalli(OpCode, CallingConventions, Type, Type[], Type[])	Umieszcza instrukcję Calli w strumieniu języka microsoft intermediate language (MSIL), określając zarządzaną konwencję wywoływania dla wywołania pośredniego.

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

Źródło:

ILGenerator.cs

Umieszcza instrukcję Calli w strumieniu języka microsoft intermediate language (MSIL), określając niezarządzaną konwencję wywoływania dla wywołania pośredniego.

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

Instrukcja MSIL, która ma być emitowana do strumienia. Musi mieć wartość Calli.

unmanagedCallConv

CallingConvention

Używana jest niezarządzana konwencja wywoływania.

returnType

Type

Wynik Type .

parameterTypes

Type[]

Typy wymaganych argumentów instrukcji.

Przykłady

W poniższym przykładzie kodu pokazano kontekstowe użycie EmitCalli metody w celu wywołania metody typu niezarządzanego poza klasą dynamiczną.

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

Uwagi

Użyj EmitCalli polecenia , aby umieścić instrukcję Calli na strumieniu. Nie używaj polecenia Emit.

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

Źródło:

ILGenerator.cs

Umieszcza instrukcję Calli w strumieniu języka microsoft intermediate language (MSIL), określając zarządzaną konwencję wywoływania dla wywołania pośredniego.

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

Instrukcja MSIL, która ma być emitowana do strumienia. Musi mieć wartość Calli.

callingConvention

CallingConventions

Zarządzana konwencja wywoływania, która ma być używana.

returnType

Type

Wynik Type .

parameterTypes

Type[]

Typy wymaganych argumentów instrukcji.

optionalParameterTypes

Type[]

Typy opcjonalnych argumentów dla varargs wywołań.

Wyjątki

InvalidOperationException

optionalParameterTypes to nie null, ale callingConvention nie zawiera flagi VarArgs .

Uwagi

Użyj EmitCalli polecenia , aby umieścić instrukcję Calli na strumieniu. Nie używaj polecenia Emit.

Jeśli optionalParameterTypes określa opcjonalne argumenty, callingConvention musi zawierać flagę CallingConventions.VarArgs .