ILGenerator.Emit 方法

定义

命名空间:: System.Reflection.Emit

程序集:: netstandard.dll, System.Reflection.Emit.ILGeneration.dll

程序集:: System.Reflection.Emit.ILGeneration.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将指令置于实时（JIT）编译器的Microsoft中间语言（MSIL）流中。

重载

名称	说明
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)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于Microsoft中间语言（MSIL）流，后跟给定局部变量的索引。

public:
 abstract 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);

public abstract 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

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 MustOverride Sub Emit (opcode As OpCode, local As LocalBuilder)

Public Overridable 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)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于Microsoft中间语言（MSIL）流，后跟给定类型的元数据令牌。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要放入流的 MSIL 指令。

cls: Type

Type。

例外

ArgumentNullException

cls 是 null。

注解

指令值在枚举中 OpCodes 定义。记录的位置 cls ，以便在将模块保存到可移植可执行文件（PE）文件时，如有必要，可以修补令牌。

适用于

Emit(OpCode, String)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于Microsoft中间语言（MSIL）流中，后跟给定字符串的元数据令牌。

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

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

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

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

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

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

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

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

参数

opcode: OpCode

要发送到流的 MSIL 指令。

str: String

要 String 发出的。

注解

指令值在枚举中 OpCodes 定义。如果模块保存到可移植可执行文件（PE）文件，则会记录该位置 str 以供将来修复。

适用于

Emit(OpCode, Single)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和数值参数置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要放入流的 MSIL 指令。

arg: Single

参数 Single 在指令后立即推送到流中。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode, SByte)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: 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)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定字段的指定指令和元数据标记置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要发送到流的 MSIL 指令。

field: FieldInfo

一 FieldInfo 个表示字段。

注解

指令值在枚举中 OpCodes 定义。记录的位置 field ，以便在将模块保存到可移植可执行文件（PE）文件时，如有必要，可以修补指令流。

适用于

Emit(OpCode, SignatureHelper)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和签名令牌置于指令的Microsoft中间语言（MSIL）流中。

public:
 abstract 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);

public abstract 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

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 MustOverride Sub Emit (opcode As OpCode, signature As SignatureHelper)

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

参数

opcode: OpCode

要发送到流的 MSIL 指令。

signature: SignatureHelper

用于构造签名令牌的帮助程序。

例外

ArgumentNullException

signature 是 null。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode, Label[])

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于Microsoft中间语言（MSIL）流中，并在修复完成后留出空间以包含标签。

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

public:
 virtual 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);

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

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 MustOverride Sub Emit (opcode As OpCode, labels As Label())

Public Overridable 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 定义。

标签是使用 /> 创建的，并且标签在流中的位置是固定的。如果使用单字节指令，则标签可以表示流中最多 127 字节的跳转。 opcode 必须表示分支指令。由于分支是相对指令， label 因此将在修复过程中替换为分支的正确偏移量。

适用于

Emit(OpCode, MethodInfo)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于Microsoft中间语言（MSIL）流中，后跟给定方法的元数据令牌。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要发送到流的 MSIL 指令。

meth: MethodInfo

表示 MethodInfo 方法。

例外

ArgumentNullException

meth 是 null。

NotSupportedException

meth是属性为false的IsGenericMethodDefinition泛型方法。

注解

指令值在枚举中 OpCodes 定义。

记录的位置 meth ，以便在将模块保存到可移植可执行文件（PE）文件时，如有必要，可以修补指令流。

如果 meth 表示泛型方法，则它必须是泛型方法定义。也就是说，其 MethodInfo.IsGenericMethodDefinition 属性必须是 true。

适用于

Emit(OpCode, ConstructorInfo)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定构造函数的指定指令和元数据令牌置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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 MustOverride Sub Emit (opcode As OpCode, con As ConstructorInfo)

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

参数

opcode: OpCode

要发送到流的 MSIL 指令。

con: ConstructorInfo

表示 ConstructorInfo 构造函数。

属性: ComVisibleAttribute

例外

ArgumentNullException

con 是 null。

注解

指令值在枚举中 OpCodes 定义。

记录的位置 con ，以便在将模块保存到可移植可执行文件（PE）文件时，如有必要，可以修补指令流。

适用于

Emit(OpCode, Int64)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和数值参数置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要放入流的 MSIL 指令。

arg: Int64

在指令后立即推送到流的数值参数。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode, Int32)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和数值参数置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要放入流的 MSIL 指令。

arg: Int32

在指令后立即推送到流的数值参数。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode, Int16)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和数值参数置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要发送到流的 MSIL 指令。

arg: Int16

参数 Int 在指令后立即推送到流中。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode, Double)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和数值参数置于指令的Microsoft中间语言（MSIL）流中。

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

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

public abstract 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

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

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

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

参数

opcode: OpCode

要放入流的 MSIL 指令。在 OpCodes 枚举中定义。

arg: Double

在指令后立即推送到流的数值参数。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode, Byte)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令和字符参数置于指令Microsoft中间语言（MSIL）流中。

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

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

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

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

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

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

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

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

参数

opcode: OpCode

要放入流的 MSIL 指令。

arg: Byte

指令后立即推送到流的字符参数。

注解

指令值在枚举中 OpCodes 定义。

适用于

Emit(OpCode)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于指令流中。

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

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

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

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

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

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

Public MustOverride Sub Emit (opcode As OpCode)

Public Overridable 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)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

将指定的指令置于Microsoft中间语言（MSIL）流中，并在修复完成后留出空间以包含标签。

public:
 abstract 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);

public abstract 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

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 MustOverride Sub Emit (opcode As OpCode, label As Label)

Public Overridable 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 因此将在修复过程中替换为分支的正确偏移量。

适用于

反馈

此页面是否有帮助？