Partilhar via


InstructionEncoder Estrutura

Definição

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

public value class InstructionEncoder
public readonly struct InstructionEncoder
public struct InstructionEncoder
type InstructionEncoder = struct
Public Structure InstructionEncoder
Herança
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.

Aplica-se a