Syntaxe DebugView

2025-06-21

La propriété DebugView (disponible uniquement lors du débogage) fournit un rendu de chaîne d’arborescences d’expressions. La plupart de la syntaxe est assez simple à comprendre ; les cas spéciaux sont décrits dans les sections suivantes.

Chaque exemple est suivi d’un commentaire de bloc contenant le DebugView.

ParameterExpression

ParameterExpression Les noms de variables sont affichés avec un $ symbole au début.

Si un paramètre n’a pas de nom, il reçoit un nom généré automatiquement, tel que $var1 ou $var2.

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

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

ConstantExpression

Pour ConstantExpression les objets qui représentent des valeurs entières, des chaînes et null, la valeur de la constante est affichée.

Pour les types numériques qui ont des suffixes standard en tant que littéraux C#, le suffixe est ajouté à la valeur. Le tableau suivant présente les suffixes associés à différents types numériques.

Catégorie	Mot-clé	Suffixe
System.UInt32	uint	U
System.Int64	long	L
System.UInt64	ulong	UL
System.Double	double	D
System.Single	flotter	F
System.Decimal	décimal	M

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

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

BlockExpression

Si le type d’un BlockExpression objet diffère du type de la dernière expression dans le bloc, le type est affiché entre crochets angle (< et >). Sinon, le type de l’objet BlockExpression n’est pas affiché.

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

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

LambdaExpression

LambdaExpression les objets sont affichés avec leurs types délégués.

Si une expression lambda n’a pas de nom, elle reçoit un nom généré automatiquement, tel que #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

Si vous spécifiez une valeur par défaut pour l’objet LabelExpression , cette valeur est affichée avant l’objet LabelTarget .

Le .Label jeton indique le début de l’étiquette. Le .LabelTarget jeton indique la destination de la cible vers laquelle accéder.

Si une étiquette n’a pas de nom, elle reçoit un nom généré automatiquement, tel que #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:
    }
*/

Opérateurs vérifiés

Les opérateurs vérifiés sont affichés avec le # symbole devant l’opérateur. Par exemple, l’opérateur d’ajout vérifié s’affiche sous la forme #+.

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

Partager via