DebugView-Syntax

Artikel
03/14/2023

Die Eigenschaft DebugView (nur beim Debuggen verfügbar) bietet eine Zeichenfolgendarstellung von Ausdrucksbaumstrukturen. Der größte Teil der Syntax ist recht einfach zu verstehen; einige Sonderfälle werden in den folgenden Abschnitten beschrieben.

Jedem Beispiel folgt ein Blockkommentar, der die DebugView enthält.

ParameterExpression

Namen von ParameterExpression-Variablen werden mit einem $-Symbol am Anfang angezeigt.

Wenn ein Parameter nicht über einen Namen verfügt, wird ihm ein automatisch generierter Name zugewiesen, z. B. $var1 oder $var2.

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

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

ConstantExpression

Für ConstantExpression-Objekte, die ganzzahlige Werte, Zeichenfolgen und null darstellen, wird der Wert der Konstante angezeigt.

Für numerische Typen, die über Standardsuffixe als C#-Literale verfügen, wird das Suffix zum Wert hinzugefügt. Die folgende Tabelle zeigt die verschiedenen numerischen Typen und ihre zugeordneten Suffixe.

type	Schlüsselwort	Suffix
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

Wenn sich der Typ eines BlockExpression-Objekts vom Typ des letzten Ausdrucks im Block unterscheidet, wird der Typ in spitzen Klammern (< und >) angezeigt. Andernfalls wird der Typ des BlockExpression-Objekts nicht angezeigt.

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

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

LambdaExpression.

LambdaExpression-Objekte werden zusammen mit ihren Delegattypen angezeigt.

Wenn ein Lambda-Ausdruck keinen Namen hat, wird ihm ein automatisch generierter Name wie z. B. #Lambda1 oder #Lambda2 zugewiesen.

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

Wenn Sie einen Standardwert für das LabelExpression-Objekt angeben, wird dieser Wert vor dem LabelTarget-Objekt angezeigt.

Das .Label-Token gibt den Anfang der Bezeichnung an. Das .LabelTarget-Token gibt den Zielort an, zu dem gewechselt werden soll.

Wenn eine Bezeichnung keinen Namen hat, wird ihr ein automatisch generierter Name wie z. B. #Label1 oder #Label2 zugewiesen.

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

Überprüfte Operatoren

Überprüften Operatoren wird in der Ansicht das #-Symbol vorangestellt. Der überprüfte Additionsoperator wird z.B. als #+ angezeigt.

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

Freigeben über