ILGenerator.Emit Methode

Definitie

Naamruimte:: System.Reflection.Emit

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Hiermee plaatst u een instructie op de Microsoft MSIL-stroom (Intermediate Language) voor de Just-In-Time-compiler (JIT).

Overloads

Name	Description
Emit(OpCode, LocalBuilder)	Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door de index van de opgegeven lokale variabele.
Emit(OpCode, Type)	Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door het metagegevenstoken voor het opgegeven type.
Emit(OpCode, String)	Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door het metagegevenstoken voor de opgegeven tekenreeks.
Emit(OpCode, Single)	Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, SByte)	Hiermee zet u de opgegeven instructie- en tekenargumenten op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, MethodInfo)	Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door het metagegevenstoken voor de opgegeven methode.
Emit(OpCode, SignatureHelper)	Hiermee plaatst u de opgegeven instructie en een handtekeningtoken op de Microsoft MSIL-stroom met instructies (tussenliggende taal).
Emit(OpCode, Label[])	Zet de opgegeven instructie op de Microsoft tussentaalstroom (MSIL) en laat ruimte over om een label op te nemen wanneer er oplossingen worden uitgevoerd.
Emit(OpCode, FieldInfo)	Hiermee plaatst u het opgegeven instructie- en metagegevenstoken voor het opgegeven veld op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, ConstructorInfo)	Hiermee plaatst u het opgegeven instructie- en metagegevenstoken voor de opgegeven constructor op de stroom van instructies Microsoft tussenliggende taal (MSIL).
Emit(OpCode, Int64)	Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, Int32)	Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, Int16)	Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, Double)	Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.
Emit(OpCode, Byte)	Hiermee zet u de opgegeven instructie- en tekenargumenten op de Microsoft MSIL-stroom met instructies.
Emit(OpCode)	Zet de opgegeven instructie op de stroom instructies.
Emit(OpCode, Label)	Zet de opgegeven instructie op de Microsoft tussentaalstroom (MSIL) en laat ruimte over om een label op te nemen wanneer er oplossingen worden uitgevoerd.

Emit(OpCode, LocalBuilder)

Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door de index van de opgegeven lokale variabele.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::LocalBuilder ^ local);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.LocalBuilder local);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.LocalBuilder -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.LocalBuilder -> unit

Public Overridable Sub Emit (opcode As OpCode, local As LocalBuilder)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

local: LocalBuilder

Een lokale variabele.

Uitzonderingen

ArgumentException

De bovenliggende methode van de local parameter komt niet overeen met de methode die aan deze ILGeneratorparameter is gekoppeld.

ArgumentNullException

local is null.

InvalidOperationException

opcode is een instructie met één byte en local vertegenwoordigt een lokale variabele met een index die groter is dan Byte.MaxValue.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, Type)

Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door het metagegevenstoken voor het opgegeven type.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, Type ^ cls);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, Type cls);

abstract member Emit : System.Reflection.Emit.OpCode * Type -> unit
override this.Emit : System.Reflection.Emit.OpCode * Type -> unit

Public Overridable Sub Emit (opcode As OpCode, cls As Type)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst.

cls: Type

A Type.

Uitzonderingen

ArgumentNullException

cls is null.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming. De locatie van het bestand wordt vastgelegd, zodat het token indien nodig kan worden gepatcht bij het persistent maken van cls de module naar een draagbaar uitvoerbaar bestand (PE).

Van toepassing op

Emit(OpCode, String)

Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door het metagegevenstoken voor de opgegeven tekenreeks.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::String ^ str);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, string str);

abstract member Emit : System.Reflection.Emit.OpCode * string -> unit
override this.Emit : System.Reflection.Emit.OpCode * string -> unit

Public Overridable Sub Emit (opcode As OpCode, str As String)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

str: String

De String uit te geven.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming. De locatie wordt str vastgelegd voor toekomstige fixups als de module wordt bewaard in een draagbaar uitvoerbaar (PE)-bestand.

Van toepassing op

Emit(OpCode, Single)

Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, float arg);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, float arg);

abstract member Emit : System.Reflection.Emit.OpCode * single -> unit
override this.Emit : System.Reflection.Emit.OpCode * single -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Single)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst.

arg: Single

Het Single argument werd direct na de instructie naar de stroom gepusht.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, SByte)

Belangrijk

Deze API is niet CLS-conform.

Hiermee zet u de opgegeven instructie- en tekenargumenten op de Microsoft MSIL-stroom met instructies.

public:
 void Emit(System::Reflection::Emit::OpCode opcode, System::SByte arg);

[System.CLSCompliant(false)]
public void Emit(System.Reflection.Emit.OpCode opcode, sbyte arg);

[<System.CLSCompliant(false)>]
member this.Emit : System.Reflection.Emit.OpCode * sbyte -> unit

Public Sub Emit (opcode As OpCode, arg As SByte)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst.

arg: SByte

Het tekenargument werd direct na de instructie naar de stroom gepusht.

Kenmerken: CLSCompliantAttribute

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, MethodInfo)

Hiermee plaatst u de opgegeven instructie in de stroom Microsoft tussenliggende taal (MSIL), gevolgd door het metagegevenstoken voor de opgegeven methode.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::MethodInfo ^ meth);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.MethodInfo meth);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.MethodInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.MethodInfo -> unit

Public Overridable Sub Emit (opcode As OpCode, meth As MethodInfo)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

meth: MethodInfo

Een MethodInfo weergave van een methode.

Uitzonderingen

ArgumentNullException

meth is null.

NotSupportedException

meth is een algemene methode waarvoor de IsGenericMethodDefinition eigenschap is false.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

De locatie van wordt vastgelegd, zodat de instructiestroom indien nodig kan worden gepatcht bij het persistent maken van meth de module naar een draagbaar uitvoerbaar bestand (PE).

Als meth dit een algemene methode vertegenwoordigt, moet dit een algemene methodedefinitie zijn. Dat wil gezegd, de eigenschap MethodInfo.IsGenericMethodDefinition moet zijn true.

Van toepassing op

Emit(OpCode, SignatureHelper)

Hiermee plaatst u de opgegeven instructie en een handtekeningtoken op de Microsoft MSIL-stroom met instructies (tussenliggende taal).

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::SignatureHelper ^ signature);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.SignatureHelper signature);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.SignatureHelper -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.SignatureHelper -> unit

Public Overridable Sub Emit (opcode As OpCode, signature As SignatureHelper)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

signature: SignatureHelper

Een helper voor het maken van een handtekeningtoken.

Uitzonderingen

ArgumentNullException

signature is null.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, Label[])

Zet de opgegeven instructie op de Microsoft tussentaalstroom (MSIL) en laat ruimte over om een label op te nemen wanneer er oplossingen worden uitgevoerd.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, cli::array <System::Reflection::Emit::Label> ^ labels);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label[] labels);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label[] -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label[] -> unit

Public Overridable Sub Emit (opcode As OpCode, labels As Label())

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

labels: Label[]

De matrix van labelobjecten waarnaar moet worden vertakt vanaf deze locatie. Alle labels worden gebruikt.

Voorbeelden

Het onderstaande codevoorbeeld illustreert het maken van een dynamische methode met een jumptabel. De jumptabel wordt gebouwd met behulp van een matrix van Label.

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

class DynamicJumpTableDemo
{
   public static Type BuildMyType()
   {
    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                        myAsmName,
                        AssemblyBuilderAccess.Run);
    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
                        "MyJumpTableDemo");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
                            TypeAttributes.Public);
    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
                             MethodAttributes.Public |
                             MethodAttributes.Static,
                                             typeof(string),
                                             new Type[] {typeof(int)});

    ILGenerator myIL = myMthdBuilder.GetILGenerator();

    Label defaultCase = myIL.DefineLabel();	
    Label endOfMethod = myIL.DefineLabel();	

    // We are initializing our jump table. Note that the labels
    // will be placed later using the MarkLabel method.

    Label[] jumpTable = new Label[] { myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel() };

    // arg0, the number we passed, is pushed onto the stack.
    // In this case, due to the design of the code sample,
    // the value pushed onto the stack happens to match the
    // index of the label (in IL terms, the index of the offset
    // in the jump table). If this is not the case, such as
    // when switching based on non-integer values, rules for the correspondence
    // between the possible case values and each index of the offsets
    // must be established outside of the ILGenerator.Emit calls,
    // much as a compiler would.

    myIL.Emit(OpCodes.Ldarg_0);
    myIL.Emit(OpCodes.Switch, jumpTable);
    
    // Branch on default case
    myIL.Emit(OpCodes.Br_S, defaultCase);

    // Case arg0 = 0
    myIL.MarkLabel(jumpTable[0]);
    myIL.Emit(OpCodes.Ldstr, "are no bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 1
    myIL.MarkLabel(jumpTable[1]);
    myIL.Emit(OpCodes.Ldstr, "is one banana");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 2
    myIL.MarkLabel(jumpTable[2]);
    myIL.Emit(OpCodes.Ldstr, "are two bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 3
    myIL.MarkLabel(jumpTable[3]);
    myIL.Emit(OpCodes.Ldstr, "are three bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 4
    myIL.MarkLabel(jumpTable[4]);
    myIL.Emit(OpCodes.Ldstr, "are four bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Default case
    myIL.MarkLabel(defaultCase);
    myIL.Emit(OpCodes.Ldstr, "are many bananas");

    myIL.MarkLabel(endOfMethod);
    myIL.Emit(OpCodes.Ret);
    
    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type myType = BuildMyType();
    
    Console.Write("Enter an integer between 0 and 5: ");
    int theValue = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("---");
    Object myInstance = Activator.CreateInstance(myType, new object[0]);	
    Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe",
                               BindingFlags.InvokeMethod,
                               null,
                               myInstance,
                               new object[] {theValue}));
   }
}


Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class DynamicJumpTableDemo
   
   Public Shared Function BuildMyType() As Type

      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                            AssemblyBuilderAccess.Run)
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyJumpTableDemo")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("JumpTableDemo", _
                                 TypeAttributes.Public)
      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("SwitchMe", _
                        MethodAttributes.Public Or MethodAttributes.Static, _
                        GetType(String), New Type() {GetType(Integer)})
      
      Dim myIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      Dim defaultCase As Label = myIL.DefineLabel()
      Dim endOfMethod As Label = myIL.DefineLabel()
      
      ' We are initializing our jump table. Note that the labels
      ' will be placed later using the MarkLabel method. 

      Dim jumpTable() As Label = {myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel()}
      
      ' arg0, the number we passed, is pushed onto the stack.
      ' In this case, due to the design of the code sample,
      ' the value pushed onto the stack happens to match the
      ' index of the label (in IL terms, the index of the offset
      ' in the jump table). If this is not the case, such as
      ' when switching based on non-integer values, rules for the correspondence
      ' between the possible case values and each index of the offsets
      ' must be established outside of the ILGenerator.Emit calls,
      ' much as a compiler would.

      myIL.Emit(OpCodes.Ldarg_0)
      myIL.Emit(OpCodes.Switch, jumpTable)
      
      ' Branch on default case
      myIL.Emit(OpCodes.Br_S, defaultCase)
      
      ' Case arg0 = 0
      myIL.MarkLabel(jumpTable(0))
      myIL.Emit(OpCodes.Ldstr, "are no bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 1
      myIL.MarkLabel(jumpTable(1))
      myIL.Emit(OpCodes.Ldstr, "is one banana")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 2
      myIL.MarkLabel(jumpTable(2))
      myIL.Emit(OpCodes.Ldstr, "are two bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 3
      myIL.MarkLabel(jumpTable(3))
      myIL.Emit(OpCodes.Ldstr, "are three bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 4
      myIL.MarkLabel(jumpTable(4))
      myIL.Emit(OpCodes.Ldstr, "are four bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Default case
      myIL.MarkLabel(defaultCase)
      myIL.Emit(OpCodes.Ldstr, "are many bananas")
      
      myIL.MarkLabel(endOfMethod)
      myIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildMyType
    
   
   Public Shared Sub Main()

      Dim myType As Type = BuildMyType()
      
      Console.Write("Enter an integer between 0 and 5: ")
      Dim theValue As Integer = Convert.ToInt32(Console.ReadLine())
      
      Console.WriteLine("---")
      Dim myInstance As [Object] = Activator.CreateInstance(myType, New Object() {})
      Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe", _
                         BindingFlags.InvokeMethod, Nothing, _
                             myInstance, New Object() {theValue}))

   End Sub

End Class

Opmerkingen

Hiermee wordt een schakeltabel verzonden.

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Labels worden gemaakt met behulp van DefineLabel en hun locatie in de stream is opgelost met behulp van MarkLabel. Als een instructie met één byte wordt gebruikt, kan het label een sprong van maximaal 127 bytes langs de stream vertegenwoordigen. opcode moet een vertakkingsinstructie vertegenwoordigen. Omdat vertakkingen relatieve instructies zijn, label wordt deze vervangen door de juiste verschuiving naar vertakking tijdens het fixupproces.

Van toepassing op

Emit(OpCode, FieldInfo)

Hiermee plaatst u het opgegeven instructie- en metagegevenstoken voor het opgegeven veld op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::FieldInfo ^ field);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.FieldInfo field);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.FieldInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.FieldInfo -> unit

Public Overridable Sub Emit (opcode As OpCode, field As FieldInfo)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

field: FieldInfo

Een FieldInfo vertegenwoordiging van een veld.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming. De locatie van wordt vastgelegd, zodat de instructiestroom indien nodig kan worden gepatcht bij het persistent maken van field de module naar een draagbaar uitvoerbaar bestand (PE).

Van toepassing op

Emit(OpCode, ConstructorInfo)

Hiermee plaatst u het opgegeven instructie- en metagegevenstoken voor de opgegeven constructor op de stroom van instructies Microsoft tussenliggende taal (MSIL).

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::ConstructorInfo ^ con);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con);

[System.Runtime.InteropServices.ComVisible(true)]
public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit

[<System.Runtime.InteropServices.ComVisible(true)>]
abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit

Public Overridable Sub Emit (opcode As OpCode, con As ConstructorInfo)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

con: ConstructorInfo

Een ConstructorInfo vertegenwoordiger van een constructor.

Kenmerken: ComVisibleAttribute

Uitzonderingen

ArgumentNullException

con is null.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

De locatie van wordt vastgelegd, zodat de instructiestroom indien nodig kan worden gepatcht bij het persistent maken van con de module naar een draagbaar uitvoerbaar bestand (PE).

Van toepassing op

Emit(OpCode, Int64)

Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, long arg);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, long arg);

abstract member Emit : System.Reflection.Emit.OpCode * int64 -> unit
override this.Emit : System.Reflection.Emit.OpCode * int64 -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Long)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst.

arg: Int64

Het numerieke argument werd direct na de instructie naar de stroom gepusht.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, Int32)

Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, int arg);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, int arg);

abstract member Emit : System.Reflection.Emit.OpCode * int -> unit
override this.Emit : System.Reflection.Emit.OpCode * int -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Integer)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst.

arg: Int32

Het numerieke argument werd direct na de instructie naar de stroom gepusht.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, Int16)

Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, short arg);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, short arg);

abstract member Emit : System.Reflection.Emit.OpCode * int16 -> unit
override this.Emit : System.Reflection.Emit.OpCode * int16 -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Short)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

arg: Int16

Het Int argument werd direct na de instructie naar de stroom gepusht.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, Double)

Zet de opgegeven instructie en het numerieke argument op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, double arg);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, double arg);

abstract member Emit : System.Reflection.Emit.OpCode * double -> unit
override this.Emit : System.Reflection.Emit.OpCode * double -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Double)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst. Gedefinieerd in de OpCodes opsomming.

arg: Double

Het numerieke argument werd direct na de instructie naar de stroom gepusht.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode, Byte)

Hiermee zet u de opgegeven instructie- en tekenargumenten op de Microsoft MSIL-stroom met instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Byte arg);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, byte arg);

abstract member Emit : System.Reflection.Emit.OpCode * byte -> unit
override this.Emit : System.Reflection.Emit.OpCode * byte -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Byte)

Parameters

opcode: OpCode

De MSIL-instructie die in de stroom moet worden geplaatst.

arg: Byte

Het tekenargument werd direct na de instructie naar de stroom gepusht.

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Van toepassing op

Emit(OpCode)

Zet de opgegeven instructie op de stroom instructies.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode);

public virtual void Emit(System.Reflection.Emit.OpCode opcode);

abstract member Emit : System.Reflection.Emit.OpCode -> unit
override this.Emit : System.Reflection.Emit.OpCode -> unit

Public Overridable Sub Emit (opcode As OpCode)

Parameters

opcode: OpCode

De instructie Microsoft Intermediate Language (MSIL) die in de stroom moet worden geplaatst.

Voorbeelden

In het onderstaande codevoorbeeld ziet u het gebruik van het genereren van Emit MSIL-uitvoer via een exemplaar van ILGenerator.

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

class DynamicJumpTableDemo
{
   public static Type BuildMyType()
   {
    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                        myAsmName,
                        AssemblyBuilderAccess.Run);
    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
                        "MyJumpTableDemo");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
                            TypeAttributes.Public);
    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
                             MethodAttributes.Public |
                             MethodAttributes.Static,
                                             typeof(string),
                                             new Type[] {typeof(int)});

    ILGenerator myIL = myMthdBuilder.GetILGenerator();

    Label defaultCase = myIL.DefineLabel();	
    Label endOfMethod = myIL.DefineLabel();	

    // We are initializing our jump table. Note that the labels
    // will be placed later using the MarkLabel method.

    Label[] jumpTable = new Label[] { myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel() };

    // arg0, the number we passed, is pushed onto the stack.
    // In this case, due to the design of the code sample,
    // the value pushed onto the stack happens to match the
    // index of the label (in IL terms, the index of the offset
    // in the jump table). If this is not the case, such as
    // when switching based on non-integer values, rules for the correspondence
    // between the possible case values and each index of the offsets
    // must be established outside of the ILGenerator.Emit calls,
    // much as a compiler would.

    myIL.Emit(OpCodes.Ldarg_0);
    myIL.Emit(OpCodes.Switch, jumpTable);
    
    // Branch on default case
    myIL.Emit(OpCodes.Br_S, defaultCase);

    // Case arg0 = 0
    myIL.MarkLabel(jumpTable[0]);
    myIL.Emit(OpCodes.Ldstr, "are no bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 1
    myIL.MarkLabel(jumpTable[1]);
    myIL.Emit(OpCodes.Ldstr, "is one banana");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 2
    myIL.MarkLabel(jumpTable[2]);
    myIL.Emit(OpCodes.Ldstr, "are two bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 3
    myIL.MarkLabel(jumpTable[3]);
    myIL.Emit(OpCodes.Ldstr, "are three bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 4
    myIL.MarkLabel(jumpTable[4]);
    myIL.Emit(OpCodes.Ldstr, "are four bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Default case
    myIL.MarkLabel(defaultCase);
    myIL.Emit(OpCodes.Ldstr, "are many bananas");

    myIL.MarkLabel(endOfMethod);
    myIL.Emit(OpCodes.Ret);
    
    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type myType = BuildMyType();
    
    Console.Write("Enter an integer between 0 and 5: ");
    int theValue = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("---");
    Object myInstance = Activator.CreateInstance(myType, new object[0]);	
    Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe",
                               BindingFlags.InvokeMethod,
                               null,
                               myInstance,
                               new object[] {theValue}));
   }
}


Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class DynamicJumpTableDemo
   
   Public Shared Function BuildMyType() As Type

      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                            AssemblyBuilderAccess.Run)
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyJumpTableDemo")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("JumpTableDemo", _
                                 TypeAttributes.Public)
      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("SwitchMe", _
                        MethodAttributes.Public Or MethodAttributes.Static, _
                        GetType(String), New Type() {GetType(Integer)})
      
      Dim myIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      Dim defaultCase As Label = myIL.DefineLabel()
      Dim endOfMethod As Label = myIL.DefineLabel()
      
      ' We are initializing our jump table. Note that the labels
      ' will be placed later using the MarkLabel method. 

      Dim jumpTable() As Label = {myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel()}
      
      ' arg0, the number we passed, is pushed onto the stack.
      ' In this case, due to the design of the code sample,
      ' the value pushed onto the stack happens to match the
      ' index of the label (in IL terms, the index of the offset
      ' in the jump table). If this is not the case, such as
      ' when switching based on non-integer values, rules for the correspondence
      ' between the possible case values and each index of the offsets
      ' must be established outside of the ILGenerator.Emit calls,
      ' much as a compiler would.

      myIL.Emit(OpCodes.Ldarg_0)
      myIL.Emit(OpCodes.Switch, jumpTable)
      
      ' Branch on default case
      myIL.Emit(OpCodes.Br_S, defaultCase)
      
      ' Case arg0 = 0
      myIL.MarkLabel(jumpTable(0))
      myIL.Emit(OpCodes.Ldstr, "are no bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 1
      myIL.MarkLabel(jumpTable(1))
      myIL.Emit(OpCodes.Ldstr, "is one banana")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 2
      myIL.MarkLabel(jumpTable(2))
      myIL.Emit(OpCodes.Ldstr, "are two bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 3
      myIL.MarkLabel(jumpTable(3))
      myIL.Emit(OpCodes.Ldstr, "are three bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 4
      myIL.MarkLabel(jumpTable(4))
      myIL.Emit(OpCodes.Ldstr, "are four bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Default case
      myIL.MarkLabel(defaultCase)
      myIL.Emit(OpCodes.Ldstr, "are many bananas")
      
      myIL.MarkLabel(endOfMethod)
      myIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildMyType
    
   
   Public Shared Sub Main()

      Dim myType As Type = BuildMyType()
      
      Console.Write("Enter an integer between 0 and 5: ")
      Dim theValue As Integer = Convert.ToInt32(Console.ReadLine())
      
      Console.WriteLine("---")
      Dim myInstance As [Object] = Activator.CreateInstance(myType, New Object() {})
      Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe", _
                         BindingFlags.InvokeMethod, Nothing, _
                             myInstance, New Object() {theValue}))

   End Sub

End Class

Opmerkingen

Als voor de opcode parameter een argument is vereist, moet de aanroeper ervoor zorgen dat de lengte van het argument overeenkomt met de lengte van de gedeclareerde parameter. Anders zijn de resultaten onvoorspelbaar. Als de instructie Verzenden bijvoorbeeld een operand van 2 bytes vereist en de aanroeper een operand van vier bytes levert, verzendt de runtime twee extra bytes naar de instructiestroom. Deze extra bytes zijn Nop instructies.

De instructiewaarden worden gedefinieerd in OpCodes.

Van toepassing op

Emit(OpCode, Label)

Zet de opgegeven instructie op de Microsoft tussentaalstroom (MSIL) en laat ruimte over om een label op te nemen wanneer er oplossingen worden uitgevoerd.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::Label label);

public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label label);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label -> unit

Public Overridable Sub Emit (opcode As OpCode, label As Label)

Parameters

opcode: OpCode

De MSIL-instructie die moet worden verzonden naar de stroom.

label: Label

Het label waarnaar moet worden vertakt vanaf deze locatie.

Voorbeelden

Het onderstaande codevoorbeeld illustreert het maken van een dynamische methode met een jumptabel. De jumptabel wordt gebouwd met behulp van een matrix van Label.

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

class DynamicJumpTableDemo
{
   public static Type BuildMyType()
   {
    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                        myAsmName,
                        AssemblyBuilderAccess.Run);
    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
                        "MyJumpTableDemo");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
                            TypeAttributes.Public);
    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
                             MethodAttributes.Public |
                             MethodAttributes.Static,
                                             typeof(string),
                                             new Type[] {typeof(int)});

    ILGenerator myIL = myMthdBuilder.GetILGenerator();

    Label defaultCase = myIL.DefineLabel();	
    Label endOfMethod = myIL.DefineLabel();	

    // We are initializing our jump table. Note that the labels
    // will be placed later using the MarkLabel method.

    Label[] jumpTable = new Label[] { myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel() };

    // arg0, the number we passed, is pushed onto the stack.
    // In this case, due to the design of the code sample,
    // the value pushed onto the stack happens to match the
    // index of the label (in IL terms, the index of the offset
    // in the jump table). If this is not the case, such as
    // when switching based on non-integer values, rules for the correspondence
    // between the possible case values and each index of the offsets
    // must be established outside of the ILGenerator.Emit calls,
    // much as a compiler would.

    myIL.Emit(OpCodes.Ldarg_0);
    myIL.Emit(OpCodes.Switch, jumpTable);
    
    // Branch on default case
    myIL.Emit(OpCodes.Br_S, defaultCase);

    // Case arg0 = 0
    myIL.MarkLabel(jumpTable[0]);
    myIL.Emit(OpCodes.Ldstr, "are no bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 1
    myIL.MarkLabel(jumpTable[1]);
    myIL.Emit(OpCodes.Ldstr, "is one banana");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 2
    myIL.MarkLabel(jumpTable[2]);
    myIL.Emit(OpCodes.Ldstr, "are two bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 3
    myIL.MarkLabel(jumpTable[3]);
    myIL.Emit(OpCodes.Ldstr, "are three bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 4
    myIL.MarkLabel(jumpTable[4]);
    myIL.Emit(OpCodes.Ldstr, "are four bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Default case
    myIL.MarkLabel(defaultCase);
    myIL.Emit(OpCodes.Ldstr, "are many bananas");

    myIL.MarkLabel(endOfMethod);
    myIL.Emit(OpCodes.Ret);
    
    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type myType = BuildMyType();
    
    Console.Write("Enter an integer between 0 and 5: ");
    int theValue = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("---");
    Object myInstance = Activator.CreateInstance(myType, new object[0]);	
    Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe",
                               BindingFlags.InvokeMethod,
                               null,
                               myInstance,
                               new object[] {theValue}));
   }
}


Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class DynamicJumpTableDemo
   
   Public Shared Function BuildMyType() As Type

      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                            AssemblyBuilderAccess.Run)
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyJumpTableDemo")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("JumpTableDemo", _
                                 TypeAttributes.Public)
      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("SwitchMe", _
                        MethodAttributes.Public Or MethodAttributes.Static, _
                        GetType(String), New Type() {GetType(Integer)})
      
      Dim myIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      Dim defaultCase As Label = myIL.DefineLabel()
      Dim endOfMethod As Label = myIL.DefineLabel()
      
      ' We are initializing our jump table. Note that the labels
      ' will be placed later using the MarkLabel method. 

      Dim jumpTable() As Label = {myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel()}
      
      ' arg0, the number we passed, is pushed onto the stack.
      ' In this case, due to the design of the code sample,
      ' the value pushed onto the stack happens to match the
      ' index of the label (in IL terms, the index of the offset
      ' in the jump table). If this is not the case, such as
      ' when switching based on non-integer values, rules for the correspondence
      ' between the possible case values and each index of the offsets
      ' must be established outside of the ILGenerator.Emit calls,
      ' much as a compiler would.

      myIL.Emit(OpCodes.Ldarg_0)
      myIL.Emit(OpCodes.Switch, jumpTable)
      
      ' Branch on default case
      myIL.Emit(OpCodes.Br_S, defaultCase)
      
      ' Case arg0 = 0
      myIL.MarkLabel(jumpTable(0))
      myIL.Emit(OpCodes.Ldstr, "are no bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 1
      myIL.MarkLabel(jumpTable(1))
      myIL.Emit(OpCodes.Ldstr, "is one banana")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 2
      myIL.MarkLabel(jumpTable(2))
      myIL.Emit(OpCodes.Ldstr, "are two bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 3
      myIL.MarkLabel(jumpTable(3))
      myIL.Emit(OpCodes.Ldstr, "are three bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 4
      myIL.MarkLabel(jumpTable(4))
      myIL.Emit(OpCodes.Ldstr, "are four bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Default case
      myIL.MarkLabel(defaultCase)
      myIL.Emit(OpCodes.Ldstr, "are many bananas")
      
      myIL.MarkLabel(endOfMethod)
      myIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildMyType
    
   
   Public Shared Sub Main()

      Dim myType As Type = BuildMyType()
      
      Console.Write("Enter an integer between 0 and 5: ")
      Dim theValue As Integer = Convert.ToInt32(Console.ReadLine())
      
      Console.WriteLine("---")
      Dim myInstance As [Object] = Activator.CreateInstance(myType, New Object() {})
      Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe", _
                         BindingFlags.InvokeMethod, Nothing, _
                             myInstance, New Object() {theValue}))

   End Sub

End Class

Opmerkingen

De instructiewaarden worden gedefinieerd in de OpCodes opsomming.

Labels worden gemaakt met behulp van DefineLabelen hun locatie in de stream wordt opgelost met behulp van MarkLabel. Als een instructie met één byte wordt gebruikt, kan het label een sprong van maximaal 127 bytes langs de stream vertegenwoordigen. opcode moet een vertakkingsinstructie vertegenwoordigen. Omdat vertakkingen relatieve instructies zijn, label wordt deze vervangen door de juiste verschuiving naar vertakking tijdens het fixupproces.

Van toepassing op

Feedback

Is deze pagina nuttig?