ILGenerator.Emit 方法

定義

命名空間:

System.Reflection.Emit

組件:

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

將指令放入 Microsoft Intermediate Language（MSIL）串流，用於即時編譯器（JIT）。

多載

名稱	Description
Emit(OpCode, LocalBuilder)	將指定的指令放入 Microsoft 中介語言（MSIL）串流，接著是給定的本地變數索引。
Emit(OpCode, Type)	將指定的指令放入 Microsoft 中介語言（MSIL）串流，接著是該類型的元資料標記。
Emit(OpCode, String)	將指定的指令放入 Microsoft 中介語言（MSIL）串流，接著是該字串的元資料標記。
Emit(OpCode, Single)	將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, SByte)	將指定的指令與字元參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, FieldInfo)	將指定指令與該欄位的元資料標記放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, SignatureHelper)	將指定的指令與簽章令牌放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, Label[])	將指定的指令放入 Microsoft 中介語言（MSIL）串流，並在修正完成時留有空間以加入標籤。
Emit(OpCode, MethodInfo)	將指定指令放入 Microsoft 中介語言（MSIL）串流，接著是該方法的元資料標記。
Emit(OpCode, ConstructorInfo)	將指定指令與中繼資料標記放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, Int64)	將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, Int32)	將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, Int16)	將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, Double)	將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode, Byte)	將指定的指令與字元參數放入 Microsoft 中介語言（MSIL）指令流中。
Emit(OpCode)	將指定的指令放入指令流中。
Emit(OpCode, Label)	將指定的指令放入 Microsoft 中介語言（MSIL）串流，並在修正完成時留有空間以加入標籤。

Emit(OpCode, LocalBuilder)

來源:

ILGenerator.cs

將指定的指令放入 Microsoft 中介語言（MSIL）串流，接著是給定的本地變數索引。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

local

LocalBuilder

一個局部變數。

例外狀況

ArgumentException

參數的 local 父方法與與此 ILGenerator方法不相符。

ArgumentNullException

local 為 null。

InvalidOperationException

opcode 是一個單位元組指令，代表 local 一個索引大於 Byte.MaxValue的本地變數。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, Type)

來源:

ILGenerator.cs

將指定的指令放入 Microsoft 中介語言（MSIL）串流，接著是該類型的元資料標記。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。

cls

Type

A Type。

例外狀況

ArgumentNullException

cls 為 null。

備註

指令值在列舉中定義 OpCodes 。 記錄 的位置 cls ，以便在將模組持久化為可攜式執行檔（PE）時，必要時可修補標記。

Emit(OpCode, String)

來源:

ILGenerator.cs

將指定的指令放入 Microsoft 中介語言（MSIL）串流，接著是該字串的元資料標記。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

str

String

String該物會被發射。

備註

指令值在列舉中定義 OpCodes 。 若模組持續存在可攜式執行檔（PE）檔案，則會記錄 的位置 str 以供未來修正使用。

Emit(OpCode, Single)

來源:

ILGenerator.cs

將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。

arg

Single

Single這個爭論緊接著在指令後直接上傳到串流。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, SByte)

來源:

ILGenerator.cs

重要

此 API 不符合 CLS 規範。

將指定的指令與字元參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。

arg

SByte

字元參數在指令之後立即推送到串流中。

屬性

CLSCompliantAttribute

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, FieldInfo)

來源:

ILGenerator.cs

將指定指令與該欄位的元資料標記放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

field

FieldInfo

A FieldInfo 代表一個領域。

備註

指令值在列舉中定義 OpCodes 。 該位置 field 會被記錄，以便在將模組持久化為可攜式執行檔（PE）檔案時，必要時可對指令串流進行修補。

Emit(OpCode, SignatureHelper)

來源:

ILGenerator.cs

將指定的指令與簽章令牌放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

signature

SignatureHelper

一個協助建立簽名代幣的輔助工具。

例外狀況

ArgumentNullException

signature 為 null。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, Label[])

來源:

ILGenerator.cs

將指定的指令放入 Microsoft 中介語言（MSIL）串流，並在修正完成時留有空間以加入標籤。

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

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

labels

Label[]

從此位置分支到的標籤物件陣列。 所有標籤都會被使用。

範例

以下範例說明了如何建立一個動態方法，並使用跳轉表。 跳躍表是使用 的 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

備註

會發出開關表。

指令值在列舉中定義 OpCodes 。

標籤是用 建立 DefineLabel 的，標籤在串流中的位置則是用 MarkLabel來固定。 若使用單位元組指令，標籤最多可代表串流上 127 位元組的跳躍。 opcode 必須代表分支指令。 由於分支是相對指令， label 在修正過程中會被正確的偏移量取代。

Emit(OpCode, MethodInfo)

來源:

ILGenerator.cs

將指定指令放入 Microsoft 中介語言（MSIL）串流，接著是該方法的元資料標記。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

meth

MethodInfo

A MethodInfo 代表一種方法。

例外狀況

ArgumentNullException

meth 為 null。

NotSupportedException

meth 是一種通用方法，其 IsGenericMethodDefinition 性質為 false。

備註

指令值在列舉中定義 OpCodes 。

該位置 meth 會被記錄，以便在將模組持久化為可攜式執行檔（PE）檔案時，必要時可對指令串流進行修補。

若 meth 代表一個通用方法，則必須是通用方法定義。 也就是說，其 MethodInfo.IsGenericMethodDefinition 屬性必須為 true。

Emit(OpCode, ConstructorInfo)

來源:

ILGenerator.cs

將指定指令與中繼資料標記放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

con

ConstructorInfo

A ConstructorInfo 代表一個建造者。

例外狀況

ArgumentNullException

con 為 null。

備註

指令值在列舉中定義 OpCodes 。

該位置 con 會被記錄，以便在將模組持久化為可攜式執行檔（PE）檔案時，必要時可對指令串流進行修補。

Emit(OpCode, Int64)

來源:

ILGenerator.cs

將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。

arg

Int64

數值參數在指令之後立即推送到串流。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, Int32)

來源:

ILGenerator.cs

將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。

arg

Int32

數值參數在指令之後立即推送到串流。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, Int16)

來源:

ILGenerator.cs

將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

arg

Int16

Int這個爭論緊接著在指令後直接上傳到串流。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, Double)

來源:

ILGenerator.cs

將指定的指令與數值參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。 定義在 OpCodes 列舉中。

arg

Double

數值參數在指令之後立即推送到串流。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode, Byte)

來源:

ILGenerator.cs

將指定的指令與字元參數放入 Microsoft 中介語言（MSIL）指令流中。

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)

參數

opcode

OpCode

MSIL 指令要被放到串流上。

arg

Byte

字元參數在指令之後立即推送到串流中。

備註

指令值在列舉中定義 OpCodes 。

Emit(OpCode)

來源:

ILGenerator.cs

將指定的指令放入指令流中。

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)

參數

opcode

OpCode

將 Microsoft 中介語言（MSIL）指令放入串流。

範例

以下程式碼範例示範如何透過 Emit 的實例 ILGenerator來產生 MSIL 輸出。

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

備註

若參數 opcode 需要參數，呼叫者必須確保參數長度與宣告參數的長度相符。 否則，結果將難以預測。 例如，如果 Emit 指令需要 2 位元組的操作數，而呼叫者提供 4 位元組的操作數，執行時會額外向指令串流輸出兩個位元組。 這些額外的位元組會是 Nop 指令。

指令值定義於 OpCodes。

Emit(OpCode, Label)

來源:

ILGenerator.cs

將指定的指令放入 Microsoft 中介語言（MSIL）串流，並在修正完成時留有空間以加入標籤。

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)

參數

opcode

OpCode

MSIL 指令要輸出到串流上。

label

Label

從這個位置分支到的標籤。

範例

以下範例說明了如何建立一個動態方法，並使用跳轉表。 跳躍表是使用 的 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

備註

指令值在列舉中定義 OpCodes 。

標籤是使用 DefineLabel，標籤在串流中的位置則由 MarkLabel固定。 若使用單位元組指令，標籤最多可代表串流上 127 位元組的跳躍。 opcode 必須代表分支指令。 由於分支是相對指令， label 在修正過程中會被正確的偏移量取代。