DebugView-syntax

Artikel
03/05/2024

Egenskapen DebugView (endast tillgänglig vid felsökning) innehåller en strängåtergivning av uttrycksträd. Det mesta av syntaxen är ganska enkelt att förstå; specialfallen beskrivs i följande avsnitt.

Varje exempel följs av en blockkommentare som innehåller Felsökningsvyn.

ParameterExpression

ParameterExpression variabelnamn visas med en $ symbol i början.

Om en parameter inte har något namn tilldelas den ett automatiskt genererat namn, till exempel $var1 eller $var2.

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

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

ConstantExpression

För ConstantExpression objekt som representerar heltalsvärden, strängar och nullvisas värdet för konstanten.

För numeriska typer som har standardsuffix som C#-literaler läggs suffixet till i värdet. I följande tabell visas de suffix som är associerade med olika numeriska typer.

Typ	Nyckelord	Suffix
System.UInt32	Uint	U
System.Int64	Lång	L
System.UInt64	ulong	UL
System.Double	Dubbel	D
System.Single	Flyta	F
System.Decimal	decimal	M

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

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

BlockExpression

Om typen av ett BlockExpression objekt skiljer sig från typen av det sista uttrycket i blocket visas typen inom vinkelparenteserna (< och >). Annars visas inte objektets BlockExpression typ.

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

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

LambdaExpression

LambdaExpression objekt visas tillsammans med deras ombudstyper.

Om ett lambda-uttryck inte har något namn tilldelas det ett automatiskt genererat namn, till exempel #Lambda1 eller #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

Om du anger ett standardvärde för LabelExpression objektet visas det här värdet före objektet LabelTarget .

Token .Label anger början av etiketten. Token .LabelTarget anger målets mål att hoppa till.

Om en etikett inte har något namn tilldelas den ett automatiskt genererat namn, till exempel #Label1 eller #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:
    }
*/

Markerade operatorer

Markerade operatorer visas med symbolen # framför operatorn. Till exempel visas den markerade additionsoperatorn som #+.

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

Dela via