Interrogation basée sur l'état d'exécution (Visual Basic)

Article
06/23/2023

Considérons un code qui définit un IQueryable ou un IQueryable(Of T) par rapport à une source de données :

Dim companyNames As String() = {
    "Consolidated Messenger", "Alpine Ski House", "Southridge Video",
    "City Power & Light", "Coho Winery", "Wide World Importers",
    "Graphic Design Institute", "Adventure Works", "Humongous Insurance",
    "Woodgrove Bank", "Margie's Travel", "Northwind Traders",
    "Blue Yonder Airlines", "Trey Research", "The Phone Company",
    "Wingtip Toys", "Lucerne Publishing", "Fourth Coffee"
}

' We're using an in-memory array as the data source, but the IQueryable could have come
' from anywhere -- an ORM backed by a database, a web request, Or any other LINQ provider.
Dim companyNamesSource As IQueryable(Of String) = companyNames.AsQueryable
Dim fixedQry = companyNamesSource.OrderBy(Function(x) x)

Chaque fois que vous exécutez ce code, exactement la même requête est exécutée. Ce n’est généralement pas très utile, car vous voudrez peut-être que votre code exécute différentes requêtes en fonction des conditions au moment de l’exécution. Cet article explique comment exécuter une autre requête en fonction de l’état du runtime.

IQueryable / IQueryable(Of T) et arbres d'expression

Un IQueryable a deux composants essentiels :

Expression — représentation, indépendante du langage et des sources de données, des composants de la requête actuelle, sous la forme d’une arborescence d’expression.
Provider — instance d’un fournisseur LINQ, qui sait comment matérialiser la requête actuelle en une valeur ou un ensemble de valeurs.

Dans le contexte de requêtes dynamiques, le fournisseur reste généralement le même tandis que l’arborescence d’expression de la requête diffère d’une requête à l’autre.

Les arborescences d’expression sont immuables. Si vous souhaitez une autre arborescence d’expression, et donc une autre requête, vous devez traduire l’arborescence d’expression existante en une nouvelle, et donc en une nouvelle IQueryable.

Les sections suivantes décrivent des techniques spécifiques de requête différentes en réponse à l’état du runtime :

Utiliser l’état du runtime à partir de l’arborescence d’expression
Appeler des méthodes LINQ supplémentaires
Changer d’arborescence d’expression passée dans les méthodes LINQ
Construire un arbre d'expression Expression(Of TDelegate) en utilisant les méthodes d'usine à Expression
Ajouter des nœuds d’appel de méthode à l’arborescence d’expression d’une IQueryable
Construire des chaînes et utiliser la bibliothèque Dynamic LINQ

Utiliser l’état du runtime à partir de l’arborescence d’expression

En supposant que le fournisseur LINQ le prend en charge, le moyen le plus simple d’interroger dynamiquement consiste à référencer l’état du runtime directement dans la requête via une variable « closed-over », comme length dans l’exemple de code suivant :

Dim length = 1
Dim qry = companyNamesSource.
    Select(Function(x) x.Substring(0, length)).
    Distinct

Console.WriteLine(String.Join(", ", qry))
' prints: C, A, S, W, G, H, M, N, B, T, L, F

length = 2
Console.WriteLine(String.Join(", ", qry))
' prints: Co, Al, So, Ci, Wi, Gr, Ad, Hu, Wo, Ma, No, Bl, Tr, Th, Lu, Fo

L’arborescence d’expression interne, et donc la requête, n’ont pas été modifiées. La requête retourne des valeurs différentes uniquement parce que la valeur de length a été modifiée.

Appeler des méthodes LINQ supplémentaires

En règle générale, les méthodes LINQ intégrées sur Queryable effectuent deux étapes :

Wrapper l’arborescence d’expression actuelle dans une MethodCallExpression représentant l’appel de méthode.
Passer l’arborescence d’expression wrappée au fournisseur, soit pour retourner une valeur via la méthode IQueryProvider.Execute du fournisseur, soit pour retourner un objet de requête traduit via la méthode IQueryProvider.CreateQuery.

Vous pouvez remplacer la requête originale par le résultat d'une méthode IQueryable(Of T) pour obtenir une nouvelle requête. Vous pouvez faire cela sous conditions en fonction de l’état du runtime, comme dans l’exemple suivant :

' Dim sortByLength As Boolean  = ...

Dim qry = companyNamesSource
If sortByLength Then qry = qry.OrderBy(Function(x) x.Length)

Changer d’arborescence d’expression passée dans les méthodes LINQ

Vous pouvez passer différentes expressions aux méthodes LINQ, en fonction de l’état du runtime :

' Dim startsWith As String = ...
' Dim endsWith As String = ...

Dim expr As Expression(Of Func(Of String, Boolean))
If String.IsNullOrEmpty(startsWith) AndAlso String.IsNullOrEmpty(endsWith) Then
    expr = Function(x) True
ElseIf String.IsNullOrEmpty(startsWith) Then
    expr = Function(x) x.EndsWith(endsWith)
ElseIf String.IsNullOrEmpty(endsWith) Then
    expr = Function(x) x.StartsWith(startsWith)
Else
    expr = Function(x) x.StartsWith(startsWith) AndAlso x.EndsWith(endsWith)
End If
Dim qry = companyNamesSource.Where(expr)

Vous voudrez probablement aussi composer les différentes sous-expressions à l’aide d’une bibliothèque tierce telle que celle de LinqKit, PredicateBuilder :

' This is functionally equivalent to the previous example.

' Imports LinqKit
' Dim startsWith As String = ...
' Dim endsWith As String = ...

Dim expr As Expression(Of Func(Of String, Boolean)) = PredicateBuilder.[New](Of String)(False)
Dim original = expr
If Not String.IsNullOrEmpty(startsWith) Then expr = expr.Or(Function(x) x.StartsWith(startsWith))
If Not String.IsNullOrEmpty(endsWith) Then expr = expr.Or(Function(x) x.EndsWith(endsWith))
If expr Is original Then expr = Function(x) True

Dim qry = companyNamesSource.Where(expr)

Construire des arborescences d’expression et des requêtes avec des méthodes de fabrique

Dans tous les exemples vus jusqu’ici, nous connaissions le type d’élément au moment de la compilation, String, et donc le type de la requête, IQueryable(Of String). Vous devrez peut-être ajouter des composants à une requête de n’importe quel type d’élément ou ajouter des composants différents, en fonction du type d’élément. Vous pouvez créer des arborescences d’expression de la base jusqu’en haut en utilisant les méthodes de fabrique sur System.Linq.Expressions.Expression, et ainsi adapter l’expression au moment de l’exécution à un type d’élément spécifique.

Construction d'une expression (Of TDelegate)

Lorsque vous construisez une expression à transmettre à l'une des méthodes LINQ, vous construisez en fait une instance d'Expression(Of TDelegate), où TDelegate se trouve un type de délégué tel que Func(Of String, Boolean), Action, ou un type de délégué personnalisé.

Expression(Of TDelegate) hérite de LambdaExpression, qui représente une expression lambda complète comme la suivante :

Dim expr As Expression(Of Func(Of String, Boolean)) = Function(x As String) x.StartsWith("a")

Une LambdaExpression a deux composants :

Une liste de paramètres — (x As String) — représentée par la propriété Parameters.
Un corps — x.StartsWith("a") — représenté par la propriété Body.

Les étapes de base de la construction d'une Expression(Of TDelegate) sont les suivantes :

Définir des objets ParameterExpression pour chacun des paramètres (le cas échéant) dans l’expression lambda, en utilisant la méthode de fabrique Parameter.
```
Dim x As ParameterExpression = Parameter(GetType(String), "x")
```
Construire le corps de votre LambdaExpression en utilisant la ou les ParameterExpressions que vous avez définies et les méthodes de fabrique sur Expression. Par exemple, une expression représentant x.StartsWith("a") peut être construite comme ceci :
```
Dim body As Expression = [Call](
    x,
    GetType(String).GetMethod("StartsWith", {GetType(String)}),
    Constant("a")
)
```
Envelopper les paramètres et le corps dans une Expression(Of TDelegate) typée par le temps de compilation, en utilisant la surcharge de la Lambda méthode d'usine appropriée :
```
Dim expr As Expression(Of Func(Of String, Boolean)) =
    Lambda(Of Func(Of String, Boolean))(body, x)
```

Les sections suivantes décrivent un scénario dans lequel vous pourriez vouloir construire une Expression(Of TDelegate) à passer dans une méthode LINQ, et fournissent un exemple complet de la façon de le faire en utilisant les méthodes d'usine.

Scénario

Supposons que vous avez plusieurs types d’entités :

Public Class Person
    Property LastName As String
    Property FirstName As String
    Property DateOfBirth As Date
End Class

Public Class Car
    Property Model As String
    Property Year As Integer
End Class

Pour l’un de ces types d’entités, vous souhaitez filtrer et retourner uniquement les entités qui ont un texte donné dans l’un de leurs champs string. Pour Person, vous souhaitez rechercher dans les propriétés FirstName et LastName :

' Dim term = ...
Dim personsQry = (New List(Of Person)).AsQueryable.
    Where(Function(x) x.FirstName.Contains(term) OrElse x.LastName.Contains(term))

Par contre, pour Car, vous souhaitez rechercher uniquement dans la propriété Model :

' Dim term = ...
Dim carsQry = (New List(Of Car)).AsQueryable.
    Where(Function(x) x.Model.Contains(term))

Bien que vous puissiez écrire une fonction personnalisée pour IQueryable(Of Person) et une autre pour IQueryable(Of Car), la fonction suivante ajoute ce filtrage à n’importe quelle requête existante, quel que soit le type d’élément spécifique.

Exemple

' Imports System.Linq.Expressions.Expression
Function TextFilter(Of T)(source As IQueryable(Of T), term As String) As IQueryable(Of T)
    If String.IsNullOrEmpty(term) Then Return source

    ' T is a compile-time placeholder for the element type of the query
    Dim elementType = GetType(T)

    ' Get all the string properties on this specific type
    Dim stringProperties As PropertyInfo() =
        elementType.GetProperties.
            Where(Function(x) x.PropertyType = GetType(String)).
            ToArray
    If stringProperties.Length = 0 Then Return source

    ' Get the right overload of String.Contains
    Dim containsMethod As MethodInfo =
        GetType(String).GetMethod("Contains", {GetType(String)})

    ' Create the parameter for the expression tree --
    ' the 'x' in 'Function(x) x.PropertyName.Contains("term")'
    ' The type of the parameter is the query's element type
    Dim prm As ParameterExpression =
        Parameter(elementType)

    ' Generate an expression tree node corresponding to each property
    Dim expressions As IEnumerable(Of Expression) =
        stringProperties.Select(Of Expression)(Function(prp)
                                                   ' For each property, we want an expression node like this:
                                                   ' x.PropertyName.Contains("term")
                                                   Return [Call](      ' .Contains(...)
                                                       [Property](     ' .PropertyName
                                                           prm,        ' x
                                                           prp
                                                       ),
                                                       containsMethod,
                                                       Constant(term)  ' "term"
                                                   )
                                               End Function)

    ' Combine the individual nodes into a single expression tree node using OrElse
    Dim body As Expression =
        expressions.Aggregate(Function(prev, current) [OrElse](prev, current))

    ' Wrap the expression body in a compile-time-typed lambda expression
    Dim lmbd As Expression(Of Func(Of T, Boolean)) =
        Lambda(Of Func(Of T, Boolean))(body, prm)

    ' Because the lambda is compile-time-typed, we can use it with the Where method
    Return source.Where(lmbd)
End Function

Étant donné que la TextFilterfonction prend et renvoie un IQueryable(Of T) (et pas seulement un IQueryable ), vous pouvez ajouter d'autres éléments de requête typés par le temps de compilation après le filtre de texte.

Dim qry = TextFilter(
    (New List(Of Person)).AsQueryable,
    "abcd"
).Where(Function(x) x.DateOfBirth < #1/1/2001#)

Dim qry1 = TextFilter(
    (New List(Of Car)).AsQueryable,
    "abcd"
).Where(Function(x) x.Year = 2010)

Ajouter des nœuds d’appel de méthode à l’arborescence d’expression d’une IQueryable

Si vous avez un IQueryable au lieu d'un IQueryable(Of T), vous ne pouvez pas appeler directement les méthodes génériques LINQ. Une alternative consiste à créer l’arborescence d’expression interne comme ci-dessus et à utiliser la réflexion pour appeler la méthode LINQ appropriée lors du passage de l’arborescence d’expression.

Vous pouvez également dupliquer les fonctionnalités de la méthode LINQ, en wrappant l’arborescence entière dans une MethodCallExpression qui représente un appel à la méthode LINQ :

Function TextFilter_Untyped(source As IQueryable, term As String) As IQueryable
    If String.IsNullOrEmpty(term) Then Return source
    Dim elementType = source.ElementType

    ' The logic for building the ParameterExpression And the LambdaExpression's body is the same as in
    ' the previous example, but has been refactored into the ConstructBody function.
    Dim x As (Expression, ParameterExpression) = ConstructBody(elementType, term)
    Dim body As Expression = x.Item1
    Dim prm As ParameterExpression = x.Item2
    If body Is Nothing Then Return source

    Dim filteredTree As Expression = [Call](
        GetType(Queryable),
        "Where",
        {elementType},
        source.Expression,
        Lambda(body, prm)
    )

    Return source.Provider.CreateQuery(filteredTree)
End Function

Dans ce cas, vous n'avez pas de place T générique à la compilation, vous utiliserez donc Lambda la surcharge qui ne nécessite pas d'informations de type à la compilation et qui produit un LambdaExpression au lieu d'une Expression(Of TDelegate).

La bibliothèque Dynamic LINQ

La construction d’arborescences d’expression à l’aide de méthodes de fabrique est relativement complexe, il est plus facile de composer des chaînes. La bibliothèque Dynamic LINQ expose un ensemble de méthodes d’extension sur IQueryable correspondant aux méthodes LINQ standard sur Queryable, et qui acceptent les chaînes dans une syntaxe spéciale au lieu d’arborescences d’expression. La bibliothèque génère l’arborescence d’expression appropriée à partir de la chaîne et peut retourner la IQueryable traduite qui en résulte.

Par exemple, l'exemple précédent (y compris la construction de l'arbre d'expression) pourrait être réécrit comme suit :

' Imports System.Linq.Dynamic.Core

Function TextFilter_Strings(source As IQueryable, term As String) As IQueryable
    If String.IsNullOrEmpty(term) Then Return source

    Dim elementType = source.ElementType
    Dim stringProperties = elementType.GetProperties.
            Where(Function(x) x.PropertyType = GetType(String)).
            ToArray
    If stringProperties.Length = 0 Then Return source

    Dim filterExpr = String.Join(
        " || ",
        stringProperties.Select(Function(prp) $"{prp.Name}.Contains(@0)")
    )

    Return source.Where(filterExpr, term)
End Function

Share via