Comment Dynamic LINQ peut-il simplifier la conversion de l'arbre d'expression chaîne en LINQ ?

Conversion de chaînes en arbres d'expressions LINQ

Dans le développement de logiciels, il peut devenir nécessaire d'évaluer les expressions booléennes par rapport aux objets de données au moment de l'exécution. Une approche pour y parvenir consiste à convertir les expressions en arborescences d'expressions LINQ. Ici, nous explorons une solution optimisée pour cette tâche.

Surmonter la complexité avec Dynamic LINQ

Au lieu de créer une grammaire et un analyseur complexes, nous pouvons exploiter la bibliothèque Dynamic LINQ. Cette bibliothèque fournit une méthode pratique pour compiler dynamiquement des expressions de chaîne dans des arbres d'expression.

Mise en œuvre de la solution

À l'aide de Dynamic LINQ, la solution implique les étapes suivantes :

1. Définissez une classe contenant les propriétés souhaitées (par exemple, Personne).
2. Créez une chaîne d'expression contenant la condition booléenne (par exemple, (Person.Age > 3 AND Person.Weight > 50) OU Person.Age < 3).
3. Générez un arbre d'expression à l'aide de DynamicExpression.ParseLambda().
4. Compilez l'arborescence d'expression à l'aide de Compile().
5. Évaluez l'expression par rapport à une instance de données à l'aide DynamicInvoke().

Exemple de code

using System;
using System.Linq.Expressions;
using System.Linq.Dynamic;

class Program
{
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public int Weight { get; set; }
        public DateTime FavouriteDay { get; set; }
    }

    static void Main()
    {
        const string exp = @"(Person.Age > 3 AND Person.Weight > 50) OR Person.Age < 3";
        var p = Expression.Parameter(typeof(Person), "Person");
        var e = DynamicExpression.ParseLambda(new[] { p }, null, exp);
        var bob = new Person
        {
            Name = "Bob",
            Age = 30,
            Weight = 213,
            FavouriteDay = new DateTime(2000, 1, 1)
        };

        var result = e.Compile().DynamicInvoke(bob);
        Console.WriteLine(result);
        Console.ReadKey();
    }
}
Conclusion
En utilisant Dynamic LINQ, nous pouvons simplifier la conversion d'expressions booléennes en arbres d'expression, en éliminant le besoin d'un analyseur personnalisé. Cette solution est à la fois efficace et flexible, ce qui en fait un choix approprié pour l'évaluation dynamique d'expressions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!