InstructionEncoder Estrutura

Definição

Namespace:

System.Reflection.Metadata.Ecma335

Assembly:

System.Reflection.Metadata.dll

Pacote:

System.Reflection.Metadata v9.0.0-rc.2.24473.5

Origem:

InstructionEncoder.cs

Codifica instruções de CIL (Common Intermediate Language).

public value class InstructionEncoder

public readonly struct InstructionEncoder

type InstructionEncoder = struct

Public Structure InstructionEncoder

Herança

Object

ValueType

InstructionEncoder

Exemplos

Este exemplo mostra como emitir um corpo do método usando 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;
}

Comentários

A InstructionEncoder classe é usada para emitir instruções CIL que compõem um corpo do método. Para obter um exemplo completo de como emitir um método, consulte a documentação da MetadataBuilder classe.

Construtores

InstructionEncoder(BlobBuilder, ControlFlowBuilder)

Cria um codificador com suporte de construtores de código e de fluxo de controle.

Propriedades

CodeBuilder	Construtor subjacente no qual as instruções codificadas são gravadas.
ControlFlowBuilder	Rótulos de acompanhamento, branches e de manipuladores de exceção do construtor.
Offset	Deslocamento da próxima instrução codificada.

Métodos

Branch(ILOpCode, LabelHandle)	Codifica uma instrução branch.
Call(EntityHandle)	Codifica a call instrução e seu operando.
Call(MemberReferenceHandle)	Codifica a call instrução e seu operando.
Call(MethodDefinitionHandle)	Codifica a call instrução e seu operando.
Call(MethodSpecificationHandle)	Codifica a call instrução e seu operando.
CallIndirect(StandaloneSignatureHandle)	Codifica a calli instrução e seu operando.
DefineLabel()	Define um rótulo que pode ser usado posteriormente para marcar e se referir a um local no fluxo de instrução.
LoadArgument(Int32)	Codifica a instrução load do argumento.
LoadArgumentAddress(Int32)	Codifica a instrução load do endereço do argumento.
LoadConstantI4(Int32)	Codifica a instrução constant load Int32.
LoadConstantI8(Int64)	Codifica a instrução constant load Int64.
LoadConstantR4(Single)	Codifica a instrução constant load Single.
LoadConstantR8(Double)	Codifica a instrução constant load Double.
LoadLocal(Int32)	Codifica a instrução load variable local.
LoadLocalAddress(Int32)	Codifica a instrução variable address load local.
LoadString(UserStringHandle)	Codifica a ldstr instrução e seu operando.
MarkLabel(LabelHandle)	Associa o rótulo especificado ao deslocamento il atual.
OpCode(ILOpCode)	Codifica o código de operações especificado.
StoreArgument(Int32)	Codifica a instrução argument store.
StoreLocal(Int32)	Codifica a instrução variable store local.
Switch(Int32)	Inicia a codificação de uma instrução de comutador.
Token(EntityHandle)	Codifica um token.
Token(Int32)	Codifica um token.