如何在 C# 中创建表达式树来表示“String.Contains("term")”？答案

【问题标题】：How do I create an expression tree to represent 'String.Contains("term")' in C#?如何在 C# 中创建表达式树来表示“String.Contains("term")”？
【发布时间】：2010-09-21 16:14:56
【问题描述】：

我刚刚开始使用表达式树，所以我希望这是有道理的。我正在尝试创建一个表达式树来表示：

t => t.SomeProperty.Contains("stringValue");

到目前为止，我得到了：

    private static Expression.Lambda<Func<string, bool>> GetContainsExpression<T>(string propertyName, string propertyValue)
    {
        var parameterExp = Expression.Parameter(typeof(T), "type");
        var propertyExp = Expression.Property(parameter, propertyName);
        var containsMethodExp = Expression.*SomeMemberReferenceFunction*("Contains", propertyExp) //this is where I got lost, obviously :)
        ...
        return Expression.Lambda<Func<string, bool>>(containsMethodExp, parameterExp); //then something like this
    }

我只是不知道如何引用 String.Contains() 方法。

帮助表示赞赏。

【问题讨论】：

标签： c# .net lambda expression-trees

【解决方案1】：

类似：

class Foo
{
    public string Bar { get; set; }
}
static void Main()
{
    var lambda = GetExpression<Foo>("Bar", "abc");
    Foo foo = new Foo { Bar = "aabca" };
    bool test = lambda.Compile()(foo);
}
static Expression<Func<T, bool>> GetExpression<T>(string propertyName, string propertyValue)
{
    var parameterExp = Expression.Parameter(typeof(T), "type");
    var propertyExp = Expression.Property(parameterExp, propertyName);
    MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
    var someValue = Expression.Constant(propertyValue, typeof(string));
    var containsMethodExp = Expression.Call(propertyExp, method, someValue);

    return Expression.Lambda<Func<T, bool>>(containsMethodExp, parameterExp);
}

您可能会发现this 很有帮助。

【讨论】：

如果我想调用的不是 startWith "substring" 怎么办？
@AhmD Expression.Not 围绕 Expression.Call，并将 GetMethod 更改为 StartsWith?
如果您使用此代码向 linq2db 之类的 ORM 提供表达式，则需要将 propertyValue 提升到一个类中以将其转换为 SQL 参数。否则，如果用户从 UI 提供值，您可能会遇到 SQL 注入漏洞。类似var someValue = Expression.Property(Expression.Constant(new {Value = propertyValue}), "Value");
@Steve 任何不能正确转义或参数化 ConstantExpression 的基于表达式的 ORM 都被彻底破坏了。这本身将不会冒着SQL注入漏洞的风险。如果您使用损坏得无可救药的工具，那么您已经面临……任何事情的风险。你有一个适用的实际例子吗？这听起来像“FUD”。
@Steve 但你有一个例子，它实际上并没有逃脱。不使用参数可能是有效的.... if orm 正确地转义了输入。就个人而言，为了简单起见，我会使用参数，但这是一种设计选择。

【解决方案2】：

执行如下搜索：

ef.Entities.Where(entity => arr.Contains(entity.Name)).ToArray();

跟踪字符串将是：

SELECT .... From Entities ... Where Name In ("abc", "def", "qaz")

我使用下面创建的方法：

ef.Entities.Where(ContainsPredicate<Entity, string>(arr, "Name")).ToArray();

public Expression<Func<TEntity, bool>> ContainsPredicate<TEntity, T>(T[] arr, string fieldname) where TEntity : class {
  ParameterExpression entity = Expression.Parameter(typeof(TEntity), "entity");
  MemberExpression member = Expression.Property(entity, fieldname);

  var containsMethods = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
  .Where(m => m.Name == "Contains");
  MethodInfo method = null;
  foreach (var m in containsMethods) {
    if (m.GetParameters().Count() == 2) {
      method = m;
      break;
    }
  }
  method = method.MakeGenericMethod(member.Type);
  var exprContains = Expression.Call(method, new Expression[] { Expression.Constant(arr), member });
  return Expression.Lambda<Func<TEntity, bool>>(exprContains, entity);
}

【讨论】：

【解决方案3】：

这个怎么样：

Expression<Func<string, string, bool>> expFunc = (name, value) => name.Contains(value);

在客户端代码中：

    bool result = expFunc.Compile()("FooBar", "Foo");   //result true
    result = expFunc.Compile()("FooBar", "Boo");        //result false

【讨论】：

【解决方案4】：

这里是如何创建 string.Contains 的表达式树。

var method = typeof(Enumerable)
    .GetRuntimeMethods()
    .Single(m => m.Name == nameof(Enumerable.Contains) && m.GetParameters().Length == 2);
var containsMethod = method.MakeGenericMethod(typeof(string));
var doesContain = Expression
.Call(containsMethod, Expression.Constant(criteria.ToArray()),
 Expression.Property(p, "MyParam"));

https://raw.githubusercontent.com/xavierjohn/Its.Cqrs/e44797ef6f47424a1b145d69889bf940b5581eb8/Domain.Sql/CatchupEventFilter.cs的实际使用情况

【讨论】：