Expressiestructuren (Visual Basic)

Artikel
01/27/2024

Expressiestructuren vertegenwoordigen code in een structuurachtige gegevensstructuur, waarbij elk knooppunt een expressie is, bijvoorbeeld een methodeaanroep of een binaire bewerking, zoals x < y.

U kunt code compileren en uitvoeren die wordt vertegenwoordigd door expressiestructuren. Dit maakt dynamische aanpassing van uitvoerbare code mogelijk, de uitvoering van LINQ-query's in verschillende databases en het maken van dynamische query's. Zie Procedures voor meer informatie over expressiestructuren in LINQ: Expressiestructuren gebruiken om dynamische query's (Visual Basic) te bouwen.

Expressiestructuren worden ook gebruikt in de DYNAMIC Language Runtime (DLR) om interoperabiliteit te bieden tussen dynamische talen en de .NET Framework en om compilerschrijvers in staat te stellen expressiestructuren te verzenden in plaats van Microsoft tussenliggende taal (MSIL). Zie Het overzicht van Dynamic Language Runtime voor meer informatie over de DLR.

U kunt de C# of Visual Basic compiler een expressiestructuur laten maken op basis van een anonieme lambda-expressie, of u kunt expressiestructuren handmatig maken met behulp van de System.Linq.Expressions naamruimte.

Expressiestructuren maken vanuit Lambda-expressies

Wanneer een lambda-expressie wordt toegewezen aan een variabele van het type Expression<TDelegate>, verzendt de compiler code om een expressiestructuur te bouwen die de lambda-expressie vertegenwoordigt.

De Visual Basic compiler kan alleen expressiestructuren genereren van expressie lambdas (of lambdas met één regel). Het kan de instructie lambdas (of multi-line lambdas) niet parseren. Zie Lambda-expressies voor meer informatie over lambda-expressies in Visual Basic.

In de volgende codevoorbeelden ziet u hoe u de Visual Basic compiler een expressiestructuur maakt die de lambda-expressie Function(num) num < 5vertegenwoordigt.

Dim lambda As Expression(Of Func(Of Integer, Boolean)) =  
    Function(num) num < 5

Expressiestructuren maken met behulp van de API

Gebruik de klasse om expressiestructuren te maken met behulp van de Expression API. Deze klasse bevat statische factory-methoden waarmee expressiestructuurknooppunten van specifieke typen worden gemaakt, bijvoorbeeld , ParameterExpressiondie een variabele of parameter vertegenwoordigt, of MethodCallExpression, die een methode-aanroep vertegenwoordigt. ParameterExpression, MethodCallExpressionen de andere expressiespecifieke typen worden ook gedefinieerd in de System.Linq.Expressions naamruimte. Deze typen zijn afgeleid van het abstracte type Expression.

In het volgende codevoorbeeld ziet u hoe u een expressiestructuur maakt die de lambda-expressie Function(num) num < 5 vertegenwoordigt met behulp van de API.

' Import the following namespace to your project: System.Linq.Expressions  
  
' Manually build the expression tree for the lambda expression num => num < 5.  
Dim numParam As ParameterExpression = Expression.Parameter(GetType(Integer), "num")  
Dim five As ConstantExpression = Expression.Constant(5, GetType(Integer))  
Dim numLessThanFive As BinaryExpression = Expression.LessThan(numParam, five)  
Dim lambda1 As Expression(Of Func(Of Integer, Boolean)) =  
  Expression.Lambda(Of Func(Of Integer, Boolean))(  
        numLessThanFive,  
        New ParameterExpression() {numParam})

In .NET Framework 4 of hoger ondersteunt de API voor expressies ook toewijzingen en besturingsstroomexpressies zoals lussen, voorwaardelijke blokken en try-catch blokken. Met behulp van de API kunt u expressiestructuren maken die complexer zijn dan de structuren die kunnen worden gemaakt op basis van lambda-expressies door de Visual Basic compiler. In het volgende voorbeeld ziet u hoe u een expressiestructuur maakt waarmee de factorial van een getal wordt berekend.

' Creating a parameter expression.  
Dim value As ParameterExpression =  
    Expression.Parameter(GetType(Integer), "value")  
  
' Creating an expression to hold a local variable.
Dim result As ParameterExpression =  
    Expression.Parameter(GetType(Integer), "result")  
  
' Creating a label to jump to from a loop.  
Dim label As LabelTarget = Expression.Label(GetType(Integer))  
  
' Creating a method body.  
Dim block As BlockExpression = Expression.Block(  
    New ParameterExpression() {result},  
    Expression.Assign(result, Expression.Constant(1)),  
    Expression.Loop(  
        Expression.IfThenElse(  
            Expression.GreaterThan(value, Expression.Constant(1)),  
            Expression.MultiplyAssign(result,  
                Expression.PostDecrementAssign(value)),  
            Expression.Break(label, result)  
        ),  
        label  
    )  
)  
  
' Compile an expression tree and return a delegate.  
Dim factorial As Integer =  
    Expression.Lambda(Of Func(Of Integer, Integer))(block, value).Compile()(5)  
  
Console.WriteLine(factorial)  
' Prints 120.

Zie Dynamische methoden genereren met expressiestructuren in Visual Studio 2010, die ook van toepassing zijn op latere versies van Visual Studio voor meer informatie.

Expressiestructuren parseren

In het volgende codevoorbeeld ziet u hoe de expressiestructuur die de lambda-expressie Function(num) num < 5 vertegenwoordigt, in de onderdelen ervan kan worden uitgevouwen.

' Import the following namespace to your project: System.Linq.Expressions  
  
' Create an expression tree.  
Dim exprTree As Expression(Of Func(Of Integer, Boolean)) = Function(num) num < 5  
  
' Decompose the expression tree.  
Dim param As ParameterExpression = exprTree.Parameters(0)  
Dim operation As BinaryExpression = exprTree.Body  
Dim left As ParameterExpression = operation.Left  
Dim right As ConstantExpression = operation.Right  
  
Console.WriteLine(String.Format("Decomposed expression: {0} => {1} {2} {3}",  
                  param.Name, left.Name, operation.NodeType, right.Value))  
  
' This code produces the following output:  
'  
' Decomposed expression: num => num LessThan 5

Onveranderbaarheid van expressiestructuren

Expressiestructuren moeten onveranderbaar zijn. Dit betekent dat als u een expressiestructuur wilt wijzigen, u een nieuwe expressiestructuur moet maken door de bestaande structuur te kopiëren en knooppunten erin te vervangen. U kunt een bezoeker van een expressiestructuur gebruiken om de bestaande expressiestructuur te doorlopen. Zie Procedure: Expressiestructuren wijzigen (Visual Basic)voor meer informatie.

Expressiestructuren compileren

Het Expression<TDelegate> type biedt de Compile methode waarmee de code wordt gecompileerd die wordt vertegenwoordigd door een expressiestructuur in een uitvoerbare gemachtigde.

In het volgende codevoorbeeld ziet u hoe u een expressiestructuur compileert en de resulterende code uitvoert.

' Creating an expression tree.  
Dim expr As Expression(Of Func(Of Integer, Boolean)) =  
    Function(num) num < 5  
  
' Compiling the expression tree into a delegate.  
Dim result As Func(Of Integer, Boolean) = expr.Compile()  
  
' Invoking the delegate and writing the result to the console.  
Console.WriteLine(result(4))  
  
' Prints True.  
  
' You can also use simplified syntax  
' to compile and run an expression tree.  
' The following line can replace two previous statements.  
Console.WriteLine(expr.Compile()(4))  
  
' Also prints True.

Zie Procedure: Expressiestructuren uitvoeren (Visual Basic)voor meer informatie.

Share via