Sintaxis de DebugView

La propiedad DebugView (disponible solo durante la depuración) proporciona una representación de cadenas de árboles de expresión. La mayoría de la sintaxis es bastante sencilla de entender; los casos especiales se describen en las secciones siguientes.

Cada ejemplo va seguido de un comentario de bloque que contiene debugView.

ParameterExpression

ParameterExpression Los nombres de variable se muestran con un $ símbolo al principio.

Si un parámetro no tiene un nombre, se le asigna un nombre generado automáticamente, como $var1 o $var2.

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

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

ConstantExpression

Para ConstantExpression los objetos que representan valores enteros, cadenas y null, se muestra el valor de la constante.

Para los tipos numéricos que tienen sufijos estándar como literales de C#, el sufijo se agrega al valor. En la tabla siguiente se muestran los sufijos asociados a varios tipos numéricos.

Tipo	Palabra clave	Sufijo
System.UInt32	uint	U
System.Int64	largo	L
System.UInt64	ulong	UL
System.Double	doble	D
System.Single	flotar	F
System.Decimal	decimal	M

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

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

BlockExpression

Si el tipo de un BlockExpression objeto difiere del tipo de la última expresión del bloque, el tipo se muestra entre corchetes angulares (< y >). De lo contrario, no se muestra el BlockExpression tipo del objeto.

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

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

LambdaExpression

LambdaExpression Los objetos se muestran junto con sus tipos delegados.

Si una expresión lambda no tiene un nombre, se le asigna un nombre generado automáticamente, como #Lambda1 o #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

Si especifica un valor predeterminado para el LabelExpression objeto , este valor se muestra antes del LabelTarget objeto .

El .Label token indica el inicio de la etiqueta. El .LabelTarget token indica el destino al que se va a saltar.

Si una etiqueta no tiene un nombre, se le asigna un nombre generado automáticamente, como #Label1 o #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 comprobados

Los operadores comprobados se muestran con el # símbolo delante del operador. Por ejemplo, el operador de suma verificada se muestra 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
*/