DebugView-syntaxis

Artikel
03/05/2024

De eigenschap DebugView (alleen beschikbaar bij foutopsporing) biedt een tekenreeksweergave van expressiestructuren. De meeste syntaxis is vrij eenvoudig te begrijpen; de speciale gevallen worden beschreven in de volgende secties.

Elk voorbeeld wordt gevolgd door een blokopmerking, met daarin de Foutopsporingsweergave.

ParameterExpressie

ParameterExpression namen van variabelen worden weergegeven met een $ symbool aan het begin.

Als een parameter geen naam heeft, wordt er een automatisch gegenereerde naam toegewezen, zoals $var1 of $var2.

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

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

ConstantExpression

Voor ConstantExpression objecten die gehele getallen, tekenreeksen en nullde waarde van de constante vertegenwoordigen, wordt weergegeven.

Voor numerieke typen met standaardachtervoegsels als C#-letterlijke waarden wordt het achtervoegsel toegevoegd aan de waarde. In de volgende tabel ziet u de achtervoegsels die zijn gekoppeld aan verschillende numerieke typen.

Type	Trefwoord	Achtervoegsel
System.UInt32	Uint	U
System.Int64	Lange	L
System.UInt64	ulong	UL
System.Double	Dubbele	D
System.Single	Float	F
System.Decimal	decimaal	M

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

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

BlockExpression

Als het type van een BlockExpression object verschilt van het type van de laatste expressie in het blok, wordt het type weergegeven tussen punthaken (< en >). Anders wordt het type object BlockExpression niet weergegeven.

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

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

LambdaExpression

LambdaExpression objecten worden samen met hun gedelegeerdentypen weergegeven.

Als een lambda-expressie geen naam heeft, wordt er een automatisch gegenereerde naam toegewezen, zoals #Lambda1 of #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

Als u een standaardwaarde voor het LabelExpression object opgeeft, wordt deze waarde weergegeven vóór het LabelTarget object.

Het .Label token geeft het begin van het label aan. Het .LabelTarget token geeft de bestemming van het doel aan waar naartoe moet worden gesprongen.

Als een label geen naam heeft, wordt er een automatisch gegenereerde naam toegewezen, zoals #Label1 of #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:
    }
*/

Gecontroleerde operators

Gecontroleerde operatoren worden weergegeven met het # symbool vóór de operator. De ingeschakelde optellingsoperator wordt bijvoorbeeld weergegeven als #+.

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

Delen via