Syntaxe de DebugView

Article
03/13/2023

La propriété DebugView (disponible uniquement lors du débogage) fournit un rendu de la chaîne d’arborescences d’expression. 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 en bloc contenant DebugView.

ParameterExpression

Les noms de variables ParameterExpression s’affichent avec le symbole $ au début.

Si un paramètre n’a pas de nom, un nom généré automatiquement lui est assigné, tel que $var1 ou $var2.

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

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

ConstantExpression

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

Pour les types numériques comportant des suffixes standard comme littéraux C#, le suffixe est ajouté à la valeur. Le tableau suivant indique les suffixes associés aux différents types numériques.

Type	Mot clé	Suffixe
System.UInt32	uint	U
System.Int64	long	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

Si le type d’un objet BlockExpression diffère du type de la dernière expression du bloc, le type est affiché entre crochets pointus (< 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

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

Si une expression lambda n’a pas de nom, un nom généré automatiquement lui est assigné, 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 jeton .Label indique le début de l’étiquette. Le jeton .LabelTarget indique la destination de la cible à laquelle accéder.

Si une étiquette n’a pas de nom, un nom généré automatiquement lui est assigné, 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 Checked

Des opérateurs activés sont affichés avec le symbole # en regard de l’opérateur. Par exemple, l’opérateur d’addition checked est affiché 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