Comment puis-je évaluer dynamiquement des expressions LINQ à partir de chaînes en C# ?

Évaluation dynamique des expressions LINQ à partir de chaînes

Problème :

Étant donné une chaîne d'entrée représentant un Expression LINQ, telle que "(Person.Age > 3 AND Person.Weight > 50) OU Person.Age < 3", le but est de créer dynamiquement un Func qui peut être évalué par rapport à une instance de la classe Person.

Approche dépassée :

La solution proposée impliquant la grammaire ANTLR et le framework Predicate Builder peut être inutilement complexe.

Solution alternative : Dynamique LINQ

La bibliothèque Dynamic LINQ fournit une solution élégante et simple. Voici comment l'utiliser :

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

namespace ExpressionParser
{
    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()
        {
            // Input expression string
            const string exp = @"(Person.Age > 3 AND Person.Weight > 50) OR Person.Age < 3";

            // Compile expression into a lambda expression
            var p = Expression.Parameter(typeof(Person), "Person");
            var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p }, null, exp);

            // Create a Person instance
            var bob = new Person
            {
                Name = "Bob",
                Age = 30,
                Weight = 213,
                FavouriteDay = new DateTime(2000, 1, 1)
            };

            // Evaluate expression against the Person instance
            var result = e.Compile().DynamicInvoke(bob);

            // Print result
            Console.WriteLine(result);
            Console.ReadKey();
        }
    }
}

Dans cet exemple, nous analysons dynamiquement la chaîne d'expression en une expression lambda, puis la compilons dans un Func. Nous pouvons ensuite évaluer la fonction par rapport à une instance Person pour déterminer si elle correspond aux critères spécifiés.

Avantages de Dynamic LINQ :

• Facilité de Utiliser : API simple qui permet la construction dynamique d'expressions LINQ à partir de chaînes.
• Polyvalence : Prend en charge un large éventail d'opérateurs et de types d'expressions.
• Léger : Inclut uniquement les fonctionnalités nécessaires à l'analyse et à l'évaluation des expressions. .

Remarque : N'oubliez pas d'inclure le Package nuget System.Linq.Dynamic pour que ce code fonctionne.

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!