Sintassi di DebugView

La proprietà DebugView (disponibile solo durante il debug) fornisce un rendering in forma di stringa degli alberi delle espressioni. La maggior parte della sintassi è piuttosto semplice da comprendere e i casi speciali vengono descritti nelle sezioni seguenti.

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

ParameterExpression

I nomi delle variabili ParameterExpression 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 gli oggetti ConstantExpression che rappresentano valori interi, stringhe e null, viene visualizzato il valore della costante.

Per i tipi numerici che usano suffissi standard come valori letterali in C#, il suffisso viene aggiunto al valore. La tabella seguente mostra i suffissi associati ai vari tipi numerici.

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

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

BlockExpression

Se il tipo di un oggetto BlockExpression differisce dal tipo dell'ultima espressione nel blocco, il tipo viene visualizzato all'interno di 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

Gli oggetti LambdaExpression vengono visualizzati insieme ai rispettivi tipi delegato.

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 token .Label indica l'inizio dell'etichetta. Il token .LabelTarget indica la destinazione alla quale passare.

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 checked

Gli operatori checked vengono visualizzati con il simbolo # davanti all'operatore. Ad esempio, l'operatore di addizione checked 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
*/