Sintaxe do DebugView

Artigo
03/16/2023

A propriedade DebugView (disponível apenas durante a depuração) fornece uma renderização de cadeia de caracteres de árvores de expressão. A maior parte da sintaxe é bastante simples de entender; os casos especiais são descritos nas seções a seguir.

Cada exemplo é seguido por um comentário de bloco, que contém DebugView.

ParameterExpression

ParameterExpression os nomes de variáveis são exibidos com o símbolo $ no início.

Se um parâmetro não tiver nome, receberá um nome gerado automaticamente, como $var1 ou $var2.

ParameterExpression numParam =  Expression.Parameter(typeof(int), "num");
/*
    $num
*/

ParameterExpression numParam =  Expression.Parameter(typeof(int));
/*
    $var1
*/

ConstantExpression

Para objetos ConstantExpression que representam valores inteiros, cadeias de caracteres e null, o valor da constante é exibido.

Para tipos numéricos que têm sufixos padrão como literais de C#, o sufixo é adicionado ao valor. A tabela a seguir mostra os sufixos associados com vários tipos numéricos.

Tipo	Palavra-chave	Sufixo
System.UInt32	uint	U
System.Int64	longo	L
System.UInt64	ulong	UL
System.Double	double	D
System.Single	float	F
System.Decimal	decimal	M

int num = 10;
ConstantExpression expr = Expression.Constant(num);
/*
    10
*/

double num = 10;
ConstantExpression expr = Expression.Constant(num);
/*
    10D
*/

BlockExpression

Se o tipo de um objeto BlockExpression difere do tipo da última expressão no bloco, o tipo será exibido entre colchetes angulares (< e >). Caso contrário, o tipo do objeto BlockExpression não é exibido.

BlockExpression block = Expression.Block(Expression.Constant("test"));
/*
    .Block() {
        "test"
    }
*/

BlockExpression block =  Expression.Block(typeof(Object), Expression.Constant("test"));
/*
    .Block<System.Object>() {
        "test"
    }
*/

LambdaExpression

Objetos LambdaExpression são exibidos junto com seus tipos delegados.

Se uma expressão lambda não tiver nome, receberá um nome gerado automaticamente, como #Lambda1 ou #Lambda2.

LambdaExpression lambda =  Expression.Lambda<Func<int>>(Expression.Constant(1));
/*
    .Lambda #Lambda1<System.Func'1[System.Int32]>() {
        1
    }
*/

LambdaExpression lambda =  Expression.Lambda<Func<int>>(Expression.Constant(1), "SampleLambda", null);
/*
    .Lambda #SampleLambda<System.Func'1[System.Int32]>() {
        1
    }
*/

LabelExpression

Se você especificar um valor padrão para o objeto LabelExpression, esse valor será exibido antes do objeto LabelTarget.

O token .Label indica o início do rótulo. O token .LabelTarget indica o local para o qual o destino deve saltar.

Se um rótulo não tiver nome, receberá um nome gerado automaticamente, como #Label1 ou #Label2.

LabelTarget target = Expression.Label(typeof(int), "SampleLabel");
BlockExpression block = Expression.Block(
    Expression.Goto(target, Expression.Constant(0)),
    Expression.Label(target, Expression.Constant(-1))
);
/*
    .Block() {
        .Goto SampleLabel { 0 };
        .Label
            -1
        .LabelTarget SampleLabel:
    }
*/

LabelTarget target = Expression.Label();
BlockExpression block = Expression.Block(
    Expression.Goto(target),
    Expression.Label(target)
);
/*
    .Block() {
        .Goto #Label1 { };
        .Label
        .LabelTarget #Label1:
    }
*/

Operadores verificados

Os operadores verificados são exibidos com o símbolo # na frente do operador. Por exemplo, o operador de adição verificado é exibido como #+.

Expression expr = Expression.AddChecked( Expression.Constant(1), Expression.Constant(2));
/*
    1 #+ 2
*/

Expression expr = Expression.ConvertChecked( Expression.Constant(10.0), typeof(int));
/*
    #(System.Int32)10D
*/

Compartilhar via