ILGenerator.Emit Yöntem

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Reflection.Emit.ILGeneration.dll

Tam zamanında (JIT) derleyicisi için Microsoft Ara Dil (MSIL) akışına bir yönerge yerleştirir.

Aşırı Yüklemeler

Name	Description
Emit(OpCode, LocalBuilder)	Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen yerel değişkenin dizinine yerleştirir.
Emit(OpCode, Type)	Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen tür için meta veri belirtecine yerleştirir.
Emit(OpCode, String)	Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen dize için meta veri belirtecine yerleştirir.
Emit(OpCode, Single)	Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, SByte)	Belirtilen yönerge ve karakter bağımsız değişkenini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, FieldInfo)	Belirtilen alan için belirtilen yönergeyi ve meta veri belirtecini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, SignatureHelper)	Belirtilen yönergeyi ve imza belirtecini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, Label[])	Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına yerleştirir ve düzeltmeler yapıldığında etiket eklemek için alan bırakır.
Emit(OpCode, MethodInfo)	Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen yöntemin meta veri belirtecine yerleştirir.
Emit(OpCode, ConstructorInfo)	Belirtilen oluşturucu için belirtilen yönergeyi ve meta veri belirtecini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, Int64)	Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, Int32)	Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, Int16)	Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, Double)	Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode, Byte)	Belirtilen yönerge ve karakter bağımsız değişkenini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.
Emit(OpCode)	Belirtilen yönergeyi yönergelerin akışına yerleştirir.
Emit(OpCode, Label)	Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına yerleştirir ve düzeltmeler yapıldığında etiket eklemek için alan bırakır.

Emit(OpCode, LocalBuilder)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen yerel değişkenin dizinine yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

local

LocalBuilder

Yerel değişken.

Özel durumlar

ArgumentException

parametresinin local üst yöntemi, bu ILGeneratorile ilişkilendirilmiş yöntemle eşleşmiyor.

ArgumentNullException

local, null'e eşittir.

InvalidOperationException

opcode tek baytlık bir yönergedir ve local değerinden Byte.MaxValuebüyük bir dizine sahip yerel bir değişkeni temsil eder.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, Type)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen tür için meta veri belirtecine yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi.

cls

Type

bir Type.

Özel durumlar

ArgumentNullException

cls, null'e eşittir.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır. konumu cls kaydedilir, böylece modülü taşınabilir yürütülebilir (PE) dosyada kalıcı hale getirme sırasında gerekirse belirtecin düzeltme eki uygulanabilmesi sağlanır.

Emit(OpCode, String)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen dize için meta veri belirtecine yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

str

String

String Yayılacak.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır. Modülün str taşınabilir yürütülebilir (PE) dosyasında kalıcı olması durumunda konumu gelecekteki düzeltmeler için kaydedilir.

Emit(OpCode, Single)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi.

arg

Single

Bağımsız değişken yönergeden Single hemen sonra akışa iletildi.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, SByte)

Kaynak:

ILGenerator.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen yönerge ve karakter bağımsız değişkenini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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)

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi.

arg

SByte

Yönergeden hemen sonra akışa gönderilen karakter bağımsız değişkeni.

Öznitelikler

CLSCompliantAttribute

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, FieldInfo)

Kaynak:

ILGenerator.cs

Belirtilen alan için belirtilen yönergeyi ve meta veri belirtecini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

field

FieldInfo

Bir FieldInfo alanı temsil eden.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır. konumu field kaydedilir, böylece modül taşınabilir yürütülebilir dosyada (PE) kalıcı hale geldiğinde yönerge akışına düzeltme eki uygulanabilir.

Emit(OpCode, SignatureHelper)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi ve imza belirtecini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

signature

SignatureHelper

İmza belirteci oluşturmak için bir yardımcı.

Özel durumlar

ArgumentNullException

signature, null'e eşittir.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, Label[])

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına yerleştirir ve düzeltmeler yapıldığında etiket eklemek için alan bırakır.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

labels

Label[]

Bu konumdan dallanmaları gereken etiket nesneleri dizisi. Tüm etiketler kullanılır.

Örnekler

Aşağıdaki kod örneği, atlama tablosuyla dinamik bir yöntem oluşturmayı gösterir. Atlama tablosu bir dizisi Labelkullanılarak oluşturulur.

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

Açıklamalar

Bir switch tablosu yayar.

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Etiketler kullanılarak DefineLabel oluşturulur ve akış içindeki konumları kullanılarak MarkLabeldüzeltilir. Tek baytlık yönerge kullanılırsa etiket, akış boyunca en fazla 127 baytlık bir atlamayı temsil edebilir. opcode bir dal yönergesi temsil etmelidir. Dallar göreli yönergeler olduğundan, label düzeltme işlemi sırasında dal için doğru uzaklık ile değiştirilir.

Emit(OpCode, MethodInfo)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına ve ardından verilen yöntemin meta veri belirtecine yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

meth

MethodInfo

Bir MethodInfo yöntemi temsil eden.

Özel durumlar

ArgumentNullException

meth, null'e eşittir.

NotSupportedException

meth , özelliğinin IsGenericMethodDefinition olduğu genel bir yöntemdir false.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

konumu meth kaydedilir, böylece modül taşınabilir yürütülebilir dosyada (PE) kalıcı hale geldiğinde yönerge akışına düzeltme eki uygulanabilir.

Genel meth bir yöntemi temsil ediyorsanız, genel bir yöntem tanımı olmalıdır. Yani MethodInfo.IsGenericMethodDefinition özelliği olmalıdır true.

Emit(OpCode, ConstructorInfo)

Kaynak:

ILGenerator.cs

Belirtilen oluşturucu için belirtilen yönergeyi ve meta veri belirtecini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

con

ConstructorInfo

Bir ConstructorInfo oluşturucuyu temsil eden.

Özel durumlar

ArgumentNullException

con, null'e eşittir.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

konumu con kaydedilir, böylece modül taşınabilir yürütülebilir dosyada (PE) kalıcı hale geldiğinde yönerge akışına düzeltme eki uygulanabilir.

Emit(OpCode, Int64)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi.

arg

Int64

Sayısal bağımsız değişken yönergeden hemen sonra akışa iletildi.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, Int32)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi.

arg

Int32

Sayısal bağımsız değişken yönergeden hemen sonra akışa iletildi.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, Int16)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

arg

Int16

Bağımsız değişken yönergeden Int hemen sonra akışa iletildi.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, Double)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi ve sayısal bağımsız değişkeni Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi. Numaralandırmada OpCodes tanımlanır.

arg

Double

Sayısal bağımsız değişken yönergeden hemen sonra akışa iletildi.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode, Byte)

Kaynak:

ILGenerator.cs

Belirtilen yönerge ve karakter bağımsız değişkenini Microsoft ara dil (MSIL) yönergeleri akışına yerleştirir.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yerleştirilecek MSIL yönergesi.

arg

Byte

Yönergeden hemen sonra akışa gönderilen karakter bağımsız değişkeni.

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Emit(OpCode)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi yönergelerin akışına yerleştirir.

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

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

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

Public MustOverride Sub Emit (opcode As OpCode)

Parametreler

opcode

OpCode

Akışa yerleştirilecek Microsoft Ara Dil (MSIL) yönergesi.

Örnekler

Aşağıdaki kod örneği, bir örneği aracılığıyla MSIL çıkışı oluşturmak için uygulamasının ILGeneratorkullanımını Emit gösterir.

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

Açıklamalar

opcode Parametre bir bağımsız değişken gerektiriyorsa, çağıranın bağımsız değişken uzunluğunun bildirilen parametrenin uzunluğuyla eşleştiğinden emin olması gerekir. Aksi takdirde, sonuçlar öngörülemez olur. Örneğin, Emit yönergesi 2 baytlık bir işlenen gerektiriyorsa ve çağıran 4 baytlık bir işlenen sağlarsa, çalışma zamanı yönerge akışına iki ek bayt yayar. Bu ek baytlar yönergeler olacaktır Nop .

Yönerge değerleri içinde OpCodestanımlanır.

Emit(OpCode, Label)

Kaynak:

ILGenerator.cs

Belirtilen yönergeyi Microsoft ara dil (MSIL) akışına yerleştirir ve düzeltmeler yapıldığında etiket eklemek için alan bırakır.

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

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

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

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

Parametreler

opcode

OpCode

Akışa yayılacak MSIL yönergesi.

label

Label

Bu konumdan dallanma etiketi.

Örnekler

Aşağıdaki kod örneği, atlama tablosuyla dinamik bir yöntem oluşturmayı gösterir. Atlama tablosu bir dizisi Labelkullanılarak oluşturulur.

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

Açıklamalar

Yönerge değerleri numaralandırmada OpCodes tanımlanır.

Etiketler kullanılarak DefineLabeloluşturulur ve akış içindeki konumları kullanılarak MarkLabelsabitlenir. Tek baytlık yönerge kullanılırsa etiket, akış boyunca en fazla 127 baytlık bir atlamayı temsil edebilir. opcode bir dal yönergesi temsil etmelidir. Dallar göreli yönergeler olduğundan, label düzeltme işlemi sırasında dal için doğru uzaklık ile değiştirilir.