InstructionEncoder Estructura

Definición

Espacio de nombres:

System.Reflection.Metadata.Ecma335

Ensamblado:

System.Reflection.Metadata.dll

Source:

InstructionEncoder.cs

Codifica las instrucciones del lenguaje intermedio común (CIL).

public value class InstructionEncoder

public readonly struct InstructionEncoder

type InstructionEncoder = struct

Public Structure InstructionEncoder

Herencia

Object

ValueType

InstructionEncoder

Ejemplos

En este ejemplo se muestra cómo emitir un cuerpo del método mediante InstructionEncoder:

// The following code emits a method body similar to this C# code:

/*public static double CalcRectangleArea(double length, double width)
{
    if (length < 0.0)
    {
        throw new ArgumentOutOfRangeException("length");
    }

    if (width < 0.0)
    {
        throw new ArgumentOutOfRangeException("width");
    }

    return length * width;
}*/

private static InstructionEncoder EmitMethodBody(MetadataBuilder metadata, AssemblyReferenceHandle corlibAssemblyRef)
{
    var codeBuilder = new BlobBuilder();
    var encoder = new InstructionEncoder(codeBuilder, new ControlFlowBuilder());

    // Get a reference to the System.ArgumentOutOfRangeException type
    TypeReferenceHandle typeRefHandle = metadata.AddTypeReference(
    corlibAssemblyRef,
    metadata.GetOrAddString("System"),
    metadata.GetOrAddString("ArgumentOutOfRangeException"));

    // Signature: .ctor(string)
    var ctorSignature = new BlobBuilder();

    new BlobEncoder(ctorSignature).
        MethodSignature(isInstanceMethod: true).
        Parameters(1, returnType => returnType.Void(), parameters => parameters.AddParameter().Type().String());

    BlobHandle ctorBlobIndex = metadata.GetOrAddBlob(ctorSignature);

    // Get a reference to the System.ArgumentOutOfRangeException constructor
    MemberReferenceHandle ctorMemberRef = metadata.AddMemberReference(
        typeRefHandle,
        metadata.GetOrAddString(".ctor"),
        ctorBlobIndex);

    LabelHandle label1 = encoder.DefineLabel();
    LabelHandle label2 = encoder.DefineLabel();

    // ldarg.0
    encoder.OpCode(ILOpCode.Ldarg_0);

    // ldc.r8 0
    encoder.LoadConstantR8(0);

    // bge.un.s LABEL1
    encoder.Branch(ILOpCode.Bge_un_s, label1);

    // ldstr "length"
    encoder.LoadString(metadata.GetOrAddUserString("length"));

    // newobj instance void [System.Runtime]System.ArgumentOutOfRangeException::.ctor(string)
    encoder.OpCode(ILOpCode.Newobj);
    encoder.Token(ctorMemberRef);

    // throw
    encoder.OpCode(ILOpCode.Throw);

    // LABEL1: ldarg.1
    encoder.MarkLabel(label1);
    encoder.OpCode(ILOpCode.Ldarg_1);

    // ldc.r8 0
    encoder.LoadConstantR8(0);

    // bge.un.s LABEL2
    encoder.Branch(ILOpCode.Bge_un_s, label2);

    // ldstr "width"
    encoder.LoadString(metadata.GetOrAddUserString("width"));

    // newobj instance void [System.Runtime]System.ArgumentOutOfRangeException::.ctor(string)
    encoder.OpCode(ILOpCode.Newobj);
    encoder.Token(ctorMemberRef);

    // throw
    encoder.OpCode(ILOpCode.Throw);

    // LABEL2: ldarg.0
    encoder.MarkLabel(label2);
    encoder.OpCode(ILOpCode.Ldarg_0);

    // ldarg.1
    encoder.OpCode(ILOpCode.Ldarg_1);

    // mul
    encoder.OpCode(ILOpCode.Mul);

    // ret
    encoder.OpCode(ILOpCode.Ret);

    return encoder;
}

Comentarios

La InstructionEncoder clase se usa para emitir instrucciones CIL que componen un cuerpo del método. Para obtener un ejemplo completo de emisión de un método, consulte la documentación de la MetadataBuilder clase .

Constructores

InstructionEncoder(BlobBuilder, ControlFlowBuilder)

Crea un codificador respaldado por generadores de código y flujo de control.

Propiedades

CodeBuilder	Generador subyacente en el que se escriben las instrucciones codificadas.
ControlFlowBuilder	Controladores de excepciones, bifurcaciones y etiquetas de seguimiento del generador.
Offset	Desplazamiento de la siguiente instrucción codificada.

Métodos

Branch(ILOpCode, LabelHandle)	Codifica una instrucción de rama.
Call(EntityHandle)	Codifica la call instrucción y su operando.
Call(MemberReferenceHandle)	Codifica la call instrucción y su operando.
Call(MethodDefinitionHandle)	Codifica la call instrucción y su operando.
Call(MethodSpecificationHandle)	Codifica la call instrucción y su operando.
CallIndirect(StandaloneSignatureHandle)	Codifica la calli instrucción y su operando.
DefineLabel()	Define una etiqueta que se puede usar más adelante para marcar y hacer referencia a una ubicación en el flujo de instrucciones.
LoadArgument(Int32)	Codifica la instrucción de carga de argumentos.
LoadArgumentAddress(Int32)	Codifica la instrucción de carga de la dirección del argumento.
LoadConstantI4(Int32)	Codifica la instrucción de carga constante Int32.
LoadConstantI8(Int64)	Codifica la instrucción de carga constante Int64.
LoadConstantR4(Single)	Codifica la instrucción de carga constante Single.
LoadConstantR8(Double)	Codifica la instrucción de carga constante Double.
LoadLocal(Int32)	Codifica la instrucción de carga de variables locales.
LoadLocalAddress(Int32)	Codifica la instrucción de carga de direcciones de variable local.
LoadString(UserStringHandle)	Codifica la ldstr instrucción y su operando.
MarkLabel(LabelHandle)	Asocia la etiqueta especificada al desplazamiento de IL actual.
OpCode(ILOpCode)	Codifica el código de operación especificado.
StoreArgument(Int32)	Codifica la instrucción del almacén de argumentos.
StoreLocal(Int32)	Codifica las instrucciones del almacén de variables locales.
Switch(Int32)	Inicia la codificación de una instrucción switch.
Token(EntityHandle)	Codifica un token.
Token(Int32)	Codifica un token.