ILGenerator.EmitCall(OpCode, MethodInfo, Type[]) Metodo

Definizione

Spazio dei nomi:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Origine:

ILGenerator.cs

Inserisce un'istruzione call o callvirt nel flusso MSIL (Microsoft Intermediate Language) per chiamare un metodo varargs.

public:
 abstract void EmitCall(System::Reflection::Emit::OpCode opcode, System::Reflection::MethodInfo ^ methodInfo, cli::array <Type ^> ^ optionalParameterTypes);

public abstract void EmitCall (System.Reflection.Emit.OpCode opcode, System.Reflection.MethodInfo methodInfo, Type[]? optionalParameterTypes);

abstract member EmitCall : System.Reflection.Emit.OpCode * System.Reflection.MethodInfo * Type[] -> unit

Public MustOverride Sub EmitCall (opcode As OpCode, methodInfo As MethodInfo, optionalParameterTypes As Type())

Parametri

opcode

OpCode

Istruzione MSIL da emettere nel flusso. Deve essere Call, Callvirt o Newobj.

methodInfo

MethodInfo

Metodo varargs da chiamare.

optionalParameterTypes

Type[]

Tipi degli argomenti facoltativi se il metodo è un metodo varargs; in caso contrario, null.

Eccezioni

ArgumentException

Il parametro opcode non specifica una chiamata al metodo.

ArgumentNullException

methodInfo è null.

InvalidOperationException

La convenzione di chiamata per il metodo non è varargs, ma vengono forniti tipi di parametro facoltativi. Questa eccezione viene generata nelle versioni 1.0 e 1.1 di .NET Framework. Nelle versioni successive non viene generata alcuna eccezione.

Esempio

Nell'esempio di codice seguente vengono generati due metodi, un metodo e un varargs metodo che chiama il varargs metodo. Il EmitCall metodo viene usato per generare la chiamata al varargs metodo .

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void main() 
{
    String^ name = "InMemory";

    AssemblyBuilder^ asmBldr = 
       AppDomain::CurrentDomain->DefineDynamicAssembly(gcnew AssemblyName(name), 
          AssemblyBuilderAccess::Run);
    ModuleBuilder^ modBldr = asmBldr->DefineDynamicModule(name); 

    TypeBuilder^ tb = modBldr->DefineType("DemoVararg");

    // Create a vararg method with no return value and one 
    // string argument. (The string argument type is the only
    // element of an array of Type objects.)
    //
    MethodBuilder^ mb1 = tb->DefineMethod("VarargMethod",
        MethodAttributes::Public | MethodAttributes::Static,
        CallingConventions::VarArgs,
        nullptr, 
        gcnew array<Type^> { String::typeid });

    ILGenerator^ il1 = mb1->GetILGenerator();

    LocalBuilder^ locAi = il1->DeclareLocal(ArgIterator::typeid);
    LocalBuilder^ locNext = il1->DeclareLocal(bool::typeid);

    Label labelCheckCondition = il1->DefineLabel();
    Label labelNext = il1->DefineLabel();

    // Load the fixed argument and print it.
    il1->Emit(OpCodes::Ldarg_0);
    il1->Emit(OpCodes::Call, Console::typeid->GetMethod("Write", 
         gcnew array<Type^> { String::typeid }));

    // Load the address of the local variable represented by
    // locAi, which will hold the ArgIterator.
    il1->Emit(OpCodes::Ldloca_S, locAi);

    // Load the address of the argument list, and call the 
    // ArgIterator constructor that takes an array of runtime
    // argument handles. 
    il1->Emit(OpCodes::Arglist);
    il1->Emit(OpCodes::Call, ArgIterator::typeid->GetConstructor(
         gcnew array<Type^> { RuntimeArgumentHandle::typeid }));

    // Enter the loop at the point where the remaining argument
    // count is tested.
    il1->Emit(OpCodes::Br_S, labelCheckCondition);

    // At the top of the loop, call GetNextArg to get the next 
    // argument from the ArgIterator. Convert the typed reference
    // to an object reference and write the object to the console.
    il1->MarkLabel(labelNext);
    il1->Emit(OpCodes::Ldloca_S, locAi);
    il1->Emit(OpCodes::Call, ArgIterator::typeid->GetMethod("GetNextArg", Type::EmptyTypes));
    il1->Emit(OpCodes::Call, TypedReference::typeid->GetMethod("ToObject"));
    il1->Emit(OpCodes::Call, Console::typeid->GetMethod("Write", 
         gcnew array<Type^> { Object::typeid }));

    il1->MarkLabel(labelCheckCondition);
    il1->Emit(OpCodes::Ldloca_S, locAi);
    il1->Emit(OpCodes::Call, ArgIterator::typeid->GetMethod("GetRemainingCount"));

    // If the remaining count is greater than zero, go to
    // the top of the loop.
    il1->Emit(OpCodes::Ldc_I4_0);
    il1->Emit(OpCodes::Cgt);
    il1->Emit(OpCodes::Stloc_1);
    il1->Emit(OpCodes::Ldloc_1);
    il1->Emit(OpCodes::Brtrue_S, labelNext);

    il1->Emit(OpCodes::Ret);

    // Create a method that contains a call to the vararg 
    // method.
    MethodBuilder^ mb2 = tb->DefineMethod("CallVarargMethod",
        MethodAttributes::Public | MethodAttributes::Static,
        CallingConventions::Standard,
        nullptr, Type::EmptyTypes);

    ILGenerator^ il2 = mb2->GetILGenerator();

    // Push arguments on the stack: one for the fixed string
    // parameter, and two for the list.
    il2->Emit(OpCodes::Ldstr, "Hello ");
    il2->Emit(OpCodes::Ldstr, "world ");
    il2->Emit(OpCodes::Ldc_I4, 2006);

    // Call the vararg method, specifying the types of the 
    // arguments in the list.
    il2->EmitCall(OpCodes::Call, mb1, 
        gcnew array<Type^> { String::typeid, int::typeid });

    il2->Emit(OpCodes::Ret);

    Type^ type = tb->CreateType();
    type->GetMethod("CallVarargMethod")->Invoke(nullptr, nullptr);
}

/* This code example produces the following output:

Hello world 2006
 */

using System;
using System.Reflection;
using System.Reflection.Emit;

class Example
{
    static void Main()
    {
        string name = "InMemory";

        AssemblyBuilder asmBldr =
           AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name),
              AssemblyBuilderAccess.Run);
        ModuleBuilder modBldr = asmBldr.DefineDynamicModule(name);

        TypeBuilder tb = modBldr.DefineType("DemoVararg");

        // Create a vararg method with no return value and one
        // string argument. (The string argument type is the only
        // element of an array of Type objects.)
        //
        MethodBuilder mb1 = tb.DefineMethod("VarargMethod",
            MethodAttributes.Public | MethodAttributes.Static,
            CallingConventions.VarArgs,
            null,
            new Type[] { typeof(string) });

        ILGenerator il1 = mb1.GetILGenerator();

        LocalBuilder locAi = il1.DeclareLocal(typeof(ArgIterator));
        LocalBuilder locNext = il1.DeclareLocal(typeof(bool));

        Label labelCheckCondition = il1.DefineLabel();
        Label labelNext = il1.DefineLabel();

        // Load the fixed argument and print it.
        il1.Emit(OpCodes.Ldarg_0);
        il1.Emit(OpCodes.Call, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }));

        // Load the address of the local variable represented by
        // locAi, which will hold the ArgIterator.
        il1.Emit(OpCodes.Ldloca_S, locAi);

        // Load the address of the argument list, and call the
        // ArgIterator constructor that takes an array of runtime
        // argument handles.
        il1.Emit(OpCodes.Arglist);
        il1.Emit(OpCodes.Call, typeof(ArgIterator).GetConstructor(new Type[] { typeof(RuntimeArgumentHandle) }));

        // Enter the loop at the point where the remaining argument
        // count is tested.
        il1.Emit(OpCodes.Br_S, labelCheckCondition);

        // At the top of the loop, call GetNextArg to get the next
        // argument from the ArgIterator. Convert the typed reference
        // to an object reference and write the object to the console.
        il1.MarkLabel(labelNext);
        il1.Emit(OpCodes.Ldloca_S, locAi);
        il1.Emit(OpCodes.Call, typeof(ArgIterator).GetMethod("GetNextArg", Type.EmptyTypes));
        il1.Emit(OpCodes.Call, typeof(TypedReference).GetMethod("ToObject"));
        il1.Emit(OpCodes.Call, typeof(Console).GetMethod("Write", new Type[] { typeof(object) }));

        il1.MarkLabel(labelCheckCondition);
        il1.Emit(OpCodes.Ldloca_S, locAi);
        il1.Emit(OpCodes.Call, typeof(ArgIterator).GetMethod("GetRemainingCount"));

        // If the remaining count is greater than zero, go to
        // the top of the loop.
        il1.Emit(OpCodes.Ldc_I4_0);
        il1.Emit(OpCodes.Cgt);
        il1.Emit(OpCodes.Stloc_1);
        il1.Emit(OpCodes.Ldloc_1);
        il1.Emit(OpCodes.Brtrue_S, labelNext);

        il1.Emit(OpCodes.Ret);

        // Create a method that contains a call to the vararg
        // method.
        MethodBuilder mb2 = tb.DefineMethod("CallVarargMethod",
            MethodAttributes.Public | MethodAttributes.Static,
            CallingConventions.Standard,
            typeof(void), Type.EmptyTypes);
        ILGenerator il2 = mb2.GetILGenerator();

        // Push arguments on the stack: one for the fixed string
        // parameter, and two for the list.
        il2.Emit(OpCodes.Ldstr, "Hello ");
        il2.Emit(OpCodes.Ldstr, "world ");
        il2.Emit(OpCodes.Ldc_I4, 2006);

        // Call the vararg method, specifying the types of the
        // arguments in the list.
        il2.EmitCall(OpCodes.Call, mb1, new Type[] { typeof(string), typeof(int) });

        il2.Emit(OpCodes.Ret);

        Type type = tb.CreateType();
        type.GetMethod("CallVarargMethod").Invoke(null, null);
    }
}

/* This code example produces the following output:

Hello world 2006
 */

Imports System.Reflection
Imports System.Reflection.Emit

Class Example
    
    Shared Sub Main() 

        Dim name As String = "InMemory"
        
        Dim asmBldr As AssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( _
            New AssemblyName(name), AssemblyBuilderAccess.Run)
        Dim modBldr As ModuleBuilder = asmBldr.DefineDynamicModule(name)
        
        Dim tb As TypeBuilder = modBldr.DefineType("DemoVararg")
        
        ' Create a vararg method with no return value and one 
        ' string argument. (The string argument type is the only
        ' element of an array of Type objects.)
        '
        Dim mb1 As MethodBuilder = tb.DefineMethod("VarargMethod", _
            MethodAttributes.Public Or MethodAttributes.Static, _
            CallingConventions.VarArgs, _
            Nothing, _
            New Type() {GetType(String)})
        
        Dim il1 As ILGenerator = mb1.GetILGenerator()
        
        Dim locAi As LocalBuilder = il1.DeclareLocal(GetType(ArgIterator))
        Dim locNext As LocalBuilder = il1.DeclareLocal(GetType(Boolean))
        
        Dim labelCheckCondition As Label = il1.DefineLabel()
        Dim labelNext As Label = il1.DefineLabel()
        
        ' Load the fixed argument and print it.
        il1.Emit(OpCodes.Ldarg_0)
        il1.Emit(OpCodes.Call, GetType(Console).GetMethod("Write", _
            New Type() {GetType(String)}))
        
        ' Load the address of the local variable represented by
        ' locAi, which will hold the ArgIterator.
        il1.Emit(OpCodes.Ldloca_S, locAi)
        
        ' Load the address of the argument list, and call the 
        ' ArgIterator constructor that takes an array of runtime
        ' argument handles. 
        il1.Emit(OpCodes.Arglist)
        il1.Emit(OpCodes.Call, GetType(ArgIterator).GetConstructor( _
            New Type() {GetType(RuntimeArgumentHandle)}))
        
        ' Enter the loop at the point where the remaining argument
        ' count is tested.
        il1.Emit(OpCodes.Br_S, labelCheckCondition)
        
        ' At the top of the loop, call GetNextArg to get the next 
        ' argument from the ArgIterator. Convert the typed reference
        ' to an object reference and write the object to the console.
        il1.MarkLabel(labelNext)
        il1.Emit(OpCodes.Ldloca_S, locAi)
        il1.Emit(OpCodes.Call, _
            GetType(ArgIterator).GetMethod("GetNextArg", Type.EmptyTypes))
        il1.Emit(OpCodes.Call, GetType(TypedReference).GetMethod("ToObject"))
        il1.Emit(OpCodes.Call, _
            GetType(Console).GetMethod("Write", New Type() {GetType(Object)}))
        
        il1.MarkLabel(labelCheckCondition)
        il1.Emit(OpCodes.Ldloca_S, locAi)
        il1.Emit(OpCodes.Call, _
            GetType(ArgIterator).GetMethod("GetRemainingCount"))
        
        ' If the remaining count is greater than zero, go to
        ' the top of the loop.
        il1.Emit(OpCodes.Ldc_I4_0)
        il1.Emit(OpCodes.Cgt)
        il1.Emit(OpCodes.Stloc_1)
        il1.Emit(OpCodes.Ldloc_1)
        il1.Emit(OpCodes.Brtrue_S, labelNext)
        
        il1.Emit(OpCodes.Ret)
        
        ' Create a method that contains a call to the vararg 
        ' method.
        Dim mb2 As MethodBuilder = tb.DefineMethod("CallVarargMethod", _
            MethodAttributes.Public Or MethodAttributes.Static, _
            CallingConventions.Standard, _
            Nothing, _
            Type.EmptyTypes)

        Dim il2 As ILGenerator = mb2.GetILGenerator()
        
        ' Push arguments on the stack: one for the fixed string
        ' parameter, and two for the list.
        il2.Emit(OpCodes.Ldstr, "Hello ")
        il2.Emit(OpCodes.Ldstr, "world ")
        il2.Emit(OpCodes.Ldc_I4, 2006)
        
        ' Call the vararg method, specifying the types of the 
        ' arguments in the list.
        il2.EmitCall(OpCodes.Call, mb1, _
            New Type() {GetType(String), GetType(Integer)})
        
        il2.Emit(OpCodes.Ret)
        
        Dim myType As Type = tb.CreateType()
        myType.GetMethod("CallVarargMethod").Invoke(Nothing, Nothing)
    
    End Sub 
End Class 

' This code example produces the following output:
'
'Hello world 2006
'

Commenti

Il EmitCall metodo viene usato per generare chiamate ai varargs metodi perché non è presente alcun overload del Emit metodo che specifica i tipi di parametri degli argomenti delle variabili.

Per generare chiamate a metodi che non usano la convenzione chiamante, usare l'overload VarArgs del Emit(OpCode, MethodInfo) metodo.

Il metodo non genera un'eccezione EmitCall quando i tipi di parametri facoltativi vengono specificati per un metodo che non varargsè . InvalidProgramException viene generato quando viene eseguita la chiamata.