Sintassi DebugView

La proprietà DebugView (disponibile solo durante il debug) fornisce un rendering di stringhe degli alberi delle espressioni. La maggior parte della sintassi è piuttosto semplice da comprendere; I casi speciali sono descritti nelle sezioni seguenti.

Ogni esempio è seguito da un commento di blocco contenente DebugView.

ParameterExpression

ParameterExpression I nomi delle variabili vengono visualizzati con un $ simbolo all'inizio.

Se un parametro non ha un nome, viene assegnato un nome generato automaticamente, ad esempio $var1 o $var2.

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

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

ConstantExpression

Per ConstantExpression gli oggetti che rappresentano valori interi, stringhe e null, viene visualizzato il valore della costante .

Per i tipi numerici a cui vengono aggiunti suffissi standard come letterali in C#, il suffisso viene aggiunto al valore. Nella tabella seguente vengono illustrati i suffissi associati a vari tipi numerici.

TIPO	Parola chiave	Suffisso
System.UInt32	uint	U
System.Int64	lungo	L
System.UInt64	ulong	UL
System.Double	doppio	D
System.Single	galleggiare	F
System.Decimal	decimale	M

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

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

BlockExpression

Se il tipo di un BlockExpression oggetto è diverso dal tipo dell'ultima espressione nel blocco, il tipo viene visualizzato tra parentesi angolari (< e >). In caso contrario, il tipo dell'oggetto BlockExpression non viene visualizzato.

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

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

LambdaExpression

LambdaExpression gli oggetti vengono visualizzati insieme ai relativi tipi delegati.

Se un'espressione lambda non ha un nome, viene assegnato un nome generato automaticamente, ad esempio #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

Se si specifica un valore predefinito per l'oggetto LabelExpression , questo valore viene visualizzato prima dell'oggetto LabelTarget .

Il .Label token indica l'inizio dell'etichetta. Il .LabelTarget token indica la destinazione verso cui saltare.

Se un'etichetta non ha un nome, viene assegnato un nome generato automaticamente, ad esempio #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:
    }
*/

Operatori controllati

Gli operatori controllati vengono visualizzati con il # simbolo davanti all'operatore . Ad esempio, l'operatore di addizione controllato viene visualizzato come #+.

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
*/