Как преобразовать строку в эквивалентное дерево выражений LINQ?

173

Это упрощенная версия оригинальной задачи.

У меня есть класс под названием Person:

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

... и давайте скажем экземпляр:

var bob = new Person {
  Name = "Bob",
  Age = 30,
  Weight = 213,
  FavouriteDay = '1/1/2000'
}

Я хотел бы написать следующее в виде строки в моем любимом текстовом редакторе ....

(Person.Age > 3 AND Person.Weight > 50) OR Person.Age < 3

Я хотел бы взять эту строку и мой экземпляр объекта и оценить ИСТИНА или ЛОЖЬ - то есть вычисление Func <Person, bool> на экземпляре объекта.

Вот мои нынешние мысли:

  1. Реализовать базовую грамматику в ANTLR для поддержки базовых сравнений и логических операторов. Я думаю о копировании приоритета Visual Basic и некоторых из набора функций здесь: http://msdn.microsoft.com/en-us/library/fw84t893(VS.80).aspx
  2. Пусть ANTLR создаст подходящий AST из предоставленной строки.
  3. Пройдите AST и используйте Построителя Предикатов инфраструктуру для динамического создания Func <Person, bool>
  4. Оцените предикат против экземпляра Person по мере необходимости

Мой вопрос: я полностью переварила это? какие-нибудь альтернативы?


РЕДАКТИРОВАТЬ: Выбранное решение

Я решил использовать Dynamic Linq Library, в частности класс Dynamic Query, предоставленный в LINQSamples.

Код ниже:

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()
    {
      const string exp = @"(Person.Age > 3 AND Person.Weight > 50) OR Person.Age < 3";
      var p = Expression.Parameter(typeof(Person), "Person");
      var e = System.Linq.Dynamic.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();
    }
  }
}

Результат имеет тип System.Boolean, и в этом случае TRUE.

Большое спасибо Марку Гравеллу.

Включите пакет nuget System.Linq.Dynamic , документацию здесь

Codebrain
источник
33
Спасибо за размещение полного кода решения вместе с вашим вопросом. Очень признателен.
Адриан Григор
Что делать, если у вас есть коллекция или люди и хотели бы отфильтровать некоторые элементы? Person.Age> 3 AND Person.Weight> 50?
Серхио
Спасибо. Я не могу найти DynamicExpression.ParseLambda (). В каком пространстве имен и сборке он находится?
Мэтт Фицморис
Все хорошо .. Между пространствами имен была двусмысленность. Нужно - используя E = System.Linq.Expressions; using System.Linq.Dynamic;
Мэтт Фицморис
Почему он использует «И» вместо «&&». Разве это не должен быть код C #?
Трийнко

Ответы:

65

Поможет ли здесь динамическая библиотека linq ? В частности, я думаю, как Whereоговорка. Если необходимо, поместите его в список / массив, чтобы вызвать .Where(string)его! т.е.

var people = new List<Person> { person };
int match = people.Where(filter).Any();

Если нет, то написание парсера (использующего Expressionпод капотом) не очень обременительно - я написал один подобный (хотя я не думаю, что у меня есть источник) в моем поезде, перед самым рождеством ...

Марк Гравелл
источник
Пометьте, что вы подразумеваете под «написанием синтаксического анализатора (с использованием Expression под капотом)» и затем генерацией дерева выражений, или же в System.Linq.Expressions есть какой-то механизм синтаксического анализа?
AK_
Я вполне уверен, что он хочет прочитать файл с выражением, сформированным как таковым, а затем перевести его как предикат и скомпилировать. Вопрос заключается в том, чтобы преобразовать вашу грамматику из строки в предикат. // Lambda expression as data in the form of an expression tree. System.Linq.Expressions.Expression<Func<int, bool>> expr = i => i < 5; // Compile the expression tree into executable code. Func<int, bool> deleg = expr.Compile(); // Invoke the method and print the output. Console.WriteLine("deleg(4) = {0}", deleg(4)); ParseLambda хорошо!
Латентность
31

Еще одна такая библиотека - это Flee

Я сделал быстрое сравнение Dynamic Linq Library и Flee и Flee было в 10 раз быстрее для выражения"(Name == \"Johan\" AND Salary > 500) OR (Name != \"Johan\" AND Salary > 300)"

Вот как вы можете написать свой код, используя Flee.

static void Main(string[] args)
{
  var context = new ExpressionContext();
  const string exp = @"(Person.Age > 3 AND Person.Weight > 50) OR Person.Age < 3";
  context.Variables.DefineVariable("Person", typeof(Person));
  var e = context.CompileDynamic(exp);

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

  context.Variables["Person"] = bob;
  var result = e.Evaluate();
  Console.WriteLine(result);
  Console.ReadKey();
}
chikak
источник
Может быть, я что-то упускаю, но как «спасение» помогает в построении дерева выражений linq?
Майкл Б. Хильдебранд
9
void Main()
{
    var testdata = new List<Ownr> {
        //new Ownr{Name = "abc", Qty = 20}, // uncomment this to see it getting filtered out
        new Ownr{Name = "abc", Qty = 2},
        new Ownr{Name = "abcd", Qty = 11},
        new Ownr{Name = "xyz", Qty = 40},
        new Ownr{Name = "ok", Qty = 5},
    };

    Expression<Func<Ownr, bool>> func = Extentions.strToFunc<Ownr>("Qty", "<=", "10");
    func = Extentions.strToFunc<Ownr>("Name", "==", "abc", func);

    var result = testdata.Where(func.ExpressionToFunc()).ToList();

    result.Dump();
}

public class Ownr
{
    public string Name { get; set; }
    public int Qty { get; set; }
}

public static class Extentions
{
    public static Expression<Func<T, bool>> strToFunc<T>(string propName, string opr, string value, Expression<Func<T, bool>> expr = null)
    {
        Expression<Func<T, bool>> func = null;
        try
        {
            var type = typeof(T);
            var prop = type.GetProperty(propName);
            ParameterExpression tpe = Expression.Parameter(typeof(T));
            Expression left = Expression.Property(tpe, prop);
            Expression right = Expression.Convert(ToExprConstant(prop, value), prop.PropertyType);
            Expression<Func<T, bool>> innerExpr = Expression.Lambda<Func<T, bool>>(ApplyFilter(opr, left, right), tpe);
            if (expr != null)
                innerExpr = innerExpr.And(expr);
            func = innerExpr;
        }
        catch (Exception ex)
        {
            ex.Dump();
        }

        return func;
    }
    private static Expression ToExprConstant(PropertyInfo prop, string value)
    {
        object val = null;

        try
        {
            switch (prop.Name)
            {
                case "System.Guid":
                    val = Guid.NewGuid();
                    break;
                default:
                    {
                        val = Convert.ChangeType(value, prop.PropertyType);
                        break;
                    }
            }
        }
        catch (Exception ex)
        {
            ex.Dump();
        }

        return Expression.Constant(val);
    }
    private static BinaryExpression ApplyFilter(string opr, Expression left, Expression right)
    {
        BinaryExpression InnerLambda = null;
        switch (opr)
        {
            case "==":
            case "=":
                InnerLambda = Expression.Equal(left, right);
                break;
            case "<":
                InnerLambda = Expression.LessThan(left, right);
                break;
            case ">":
                InnerLambda = Expression.GreaterThan(left, right);
                break;
            case ">=":
                InnerLambda = Expression.GreaterThanOrEqual(left, right);
                break;
            case "<=":
                InnerLambda = Expression.LessThanOrEqual(left, right);
                break;
            case "!=":
                InnerLambda = Expression.NotEqual(left, right);
                break;
            case "&&":
                InnerLambda = Expression.And(left, right);
                break;
            case "||":
                InnerLambda = Expression.Or(left, right);
                break;
        }
        return InnerLambda;
    }

    public static Expression<Func<T, TResult>> And<T, TResult>(this Expression<Func<T, TResult>> expr1, Expression<Func<T, TResult>> expr2)
    {
        var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
        return Expression.Lambda<Func<T, TResult>>(Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters);
    }

    public static Func<T, TResult> ExpressionToFunc<T, TResult>(this Expression<Func<T, TResult>> expr)
    {
        var res = expr.Compile();
        return res;
    }
}

У LinqPad есть Dump()метод

suneelsarraf
источник
где метод GetProperty?
Ален. Том
@ Alen.Toma Мне пришлось изменить код, var type = typeof(T); var prop = type.GetProperty(propName);чтобы заставить его скомпилировать.
Джайлс Робертс
Сделано это скомпилировать и выгрузить вывод
Amit
5

Вы могли бы взглянуть на DLR . Это позволяет вам оценивать и выполнять скрипты внутри приложения .NET 2.0. Вот пример с IronRuby :

using System;
using IronRuby;
using IronRuby.Runtime;
using Microsoft.Scripting.Hosting;

class App
{
    static void Main()
    {
        var setup = new ScriptRuntimeSetup();
        setup.LanguageSetups.Add(
            new LanguageSetup(
                typeof(RubyContext).AssemblyQualifiedName,
                "IronRuby",
                new[] { "IronRuby" },
                new[] { ".rb" }
            )
        );
        var runtime = new ScriptRuntime(setup);
        var engine = runtime.GetEngine("IronRuby");
        var ec = Ruby.GetExecutionContext(runtime);
        ec.DefineGlobalVariable("bob", new Person
        {
            Name = "Bob",
            Age = 30,
            Weight = 213,
            FavouriteDay = "1/1/2000"
        });
        var eval = engine.Execute<bool>(
            "return ($bob.Age > 3 && $bob.Weight > 50) || $bob.Age < 3"
        );
        Console.WriteLine(eval);

    }
}

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

Конечно, этот метод основан на оценке во время выполнения, и код не может быть проверен во время компиляции.

Дарин димитров
источник
1
Я хочу иметь возможность защитить от выполнения «плохого кода» ... это было бы хорошо?
Codebrain
Что вы подразумеваете под «плохим кодом»? Кто-то печатает недопустимое выражение? В этом случае вы получите исключение времени выполнения при попытке оценить скрипт.
Дарин Димитров
@darin, такие как запуск процессов, изменение данных и т. д.
sisve
2
«плохой код» = то, что не является выражением типа Func <Person, bool> (например, удаление файлов с диска,
ускорение
1

Вот пример Scala DSL-комбинатора синтаксического анализа для анализа и вычисления арифметических выражений.

import scala.util.parsing.combinator._
/** 
* @author Nicolae Caralicea
* @version 1.0, 04/01/2013
*/
class Arithm extends JavaTokenParsers {
  def expr: Parser[List[String]] = term ~ rep(addTerm | minusTerm) ^^
    { case termValue ~ repValue => termValue ::: repValue.flatten }

  def addTerm: Parser[List[String]] = "+" ~ term ^^
    { case "+" ~ termValue => termValue ::: List("+") }

  def minusTerm: Parser[List[String]] = "-" ~ term ^^
    { case "-" ~ termValue => termValue ::: List("-") }

  def term: Parser[List[String]] = factor ~ rep(multiplyFactor | divideFactor) ^^
    {
      case factorValue1 ~ repfactor => factorValue1 ::: repfactor.flatten
    }

  def multiplyFactor: Parser[List[String]] = "*" ~ factor ^^
    { case "*" ~ factorValue => factorValue ::: List("*") }

  def divideFactor: Parser[List[String]] = "/" ~ factor ^^
    { case "/" ~ factorValue => factorValue ::: List("/") }

  def factor: Parser[List[String]] = floatingPointConstant | parantExpr

  def floatingPointConstant: Parser[List[String]] = floatingPointNumber ^^
    {
      case value => List[String](value)
    }

  def parantExpr: Parser[List[String]] = "(" ~ expr ~ ")" ^^
    {
      case "(" ~ exprValue ~ ")" => exprValue
    }

  def evaluateExpr(expression: String): Double = {
    val parseRes = parseAll(expr, expression)
    if (parseRes.successful) evaluatePostfix(parseRes.get)
    else throw new RuntimeException(parseRes.toString())
  }
  private def evaluatePostfix(postfixExpressionList: List[String]): Double = {
    import scala.collection.immutable.Stack

    def multiply(a: Double, b: Double) = a * b
    def divide(a: Double, b: Double) = a / b
    def add(a: Double, b: Double) = a + b
    def subtract(a: Double, b: Double) = a - b

    def executeOpOnStack(stack: Stack[Any], operation: (Double, Double) => Double): (Stack[Any], Double) = {
      val el1 = stack.top
      val updatedStack1 = stack.pop
      val el2 = updatedStack1.top
      val updatedStack2 = updatedStack1.pop
      val value = operation(el2.toString.toDouble, el1.toString.toDouble)
      (updatedStack2.push(operation(el2.toString.toDouble, el1.toString.toDouble)), value)
    }
    val initial: (Stack[Any], Double) = (Stack(), null.asInstanceOf[Double])
    val res = postfixExpressionList.foldLeft(initial)((computed, item) =>
      item match {
        case "*" => executeOpOnStack(computed._1, multiply)
        case "/" => executeOpOnStack(computed._1, divide)
        case "+" => executeOpOnStack(computed._1, add)
        case "-" => executeOpOnStack(computed._1, subtract)
        case other => (computed._1.push(other), computed._2)
      })
    res._2
  }
}

object TestArithmDSL {
  def main(args: Array[String]): Unit = {
    val arithm = new Arithm
    val actual = arithm.evaluateExpr("(12 + 4 * 6) * ((2 + 3 * ( 4 + 2 ) ) * ( 5 + 12 ))")
    val expected: Double = (12 + 4 * 6) * ((2 + 3 * ( 4 + 2 ) ) * ( 5 + 12 ))
    assert(actual == expected)
  }
}

Дерево эквивалентного выражения или дерево разбора предоставленного арифметического выражения будет иметь тип Parser [List [String]].

Более подробная информация находится по следующей ссылке:

http://nicolaecaralicea.blogspot.ca/2013/04/scala-dsl-for-parsing-and-evaluating-of.html

ncaralicea
источник
0

В дополнение к динамической библиотеке Linq (которая создает строго типизированное выражение и требует строго типизированных переменных), я рекомендую лучшую альтернативу: синтаксический анализатор linq той части библиотеки NReco Commons (с открытым исходным кодом). Он выравнивает все типы и выполняет все вызовы во время выполнения и ведет себя как динамический язык:

var lambdaParser = new NReco.LambdaParser();
var varContext = new Dictionary<string,object>();
varContext["one"] = 1M;
varContext["two"] = "2";

Console.WriteLine( lambdaParser.Eval("two>one && 0<one ? (1+8)/3+1*two : 0", varContext) ); // --> 5
Виталий Федорченко
источник