Question

public static IEnumerable<T> MyMethod<T>(this IEnumerable<T> entity, 
                                         string param, Func<T, string> selector)
{
    return entity.Where(l =>
        System.Data.Objects.SqlClient.SqlFunctions.PatIndex(param, "%"), 
                                                            selector(l)) > 0);
}

我以下列方式使用它：

dbContext.ENTITY.MyMethod("%foo", f => f.SomeProp).ToList();

但是如何使MyMethod足够通用以处理Func<T, string> selector参数上的任意数量的属性？

我想我可以将类型更改为List<Func<T, string>> selector并迭代它，但我想有更好的方法？

更新

传递两个参数时所需的结果（例如）：

dbContext.ENTITY.Where(l => 
    SqlFunctions.PatIndex("%foo", l.prop1) > 0 && 
    SqlFunctions.PatIndex("%bar%", l.prop2) > 0).ToList();

Answer 1

您可以使用params关键字接受任意数量的参数：

public static IEnumerable<T> MyMethod<T>(this IEnumerable<T> entity, 
                                         string param, 
                                         params Func<T, string>[] selectors)
{
    foreach(var selector in selectors)
    {
        entity = entity.Where(l => 
            SqlFunctions.PatIndex(param, selector(l)) > 0);
    }

    return entity;
}

但是，我怀疑这将在实体框架中按原样运作。我认为您需要使用Expression<Func<T, string>>，因此实体框架可以转换SQL：

public static IEnumerable<T> MyMethod<T>(
    this IQueryable<T> entity, 
    string pattern, 
    params Expression<Func<T, string>>[] selectors)
{
    var method = typeof(SqlFunctions).GetMethod("PatIndex");
    foreach(var selector in selectors)
    {
        var param = Expression.Parameter(typeof(T));
        var call = Expression.Call(method, Expression.Constant(pattern), selector);
        var gt = Expression.GreaterThan(call, Expression.Constant(0));
        var filter = Expression.Lamda(call, param);
        entity = entity.Where(filter);
    }

    return entity;
}

然后你可以这样称呼它：

dbContext.ENTITY.MyMethod("%foo", 
                          f => f.SomeProp1, 
                          f => f.SomeProp2, 
                          f => f.SomeProp3).ToList();

要将它与多个pattern参数一起使用，你可以使用一个字典（我不会实现方法体，因为从上面的代码中如何做到这一点应该非常明显）：

public static IEnumerable<T> MyMethod<T>(
    this IEnumerable<T> entity, 
    Dictionary<string, Func<T, bool>> filters)
{
    ...
}

你可以这样打电话：

dbContext.ENTITY.MyMethod(new Dictionary<string, Func<Entity, bool>>()
{
    { "%foo", l => l.Prop1 },
    { "%bar", l => l.Prop2 },
});

或者你可以使用一组元组：

public static IEnumerable<T> MyMethod<T>(
    this IQueryable<T> entity, 
    string pattern, 
    params Tuple<string, Func<T, string>>[] filters)
{
    ...
}

你可以这样打电话：

dbContext.ENTITY.MyMethod(
    Tuple.Create("%foo", (Func<Entity, string>)(l => l.Prop1)),
    Tuple.Create("%bar", (Func<Entity, string>)(l => l.Prop2)));

当然，您也可以创建自己的自定义类来包装这些参数，这样您就不必重复指定委托类型。

同样的技术可以很容易地应用于我上面列出的IQueryable解决方案。

Answer 2

一种选择是不做任何改变，并像这样调用现有方法：

dbContext.ENTITY
    .MyMethod("%foo", f => f.SomeProp)
    .MyMethod("%foo", f => f.AnotherProp)
    .MyMethod("%bar", b => b.SomethingElse)
    .ToList();

这是您在方法中必须要做的事情，无论如何都需要多个选择器（在循环中构建Where）。

public static IEnumerable<T> MyMethod<T>(this IEnumerable<T> entities, 
                                         string param, params Func<T, string>[] selectors)
{
    IEnumerable<T> results = entities;
    foreach(var selector in selectors)
    {
        results = results.Where(l -> …selector(l)…);
    }
    return results;
}

但是，当您想要将不同的选择器与不同的string param参数关联时，这不起作用。在这种情况下，您需要传入IDictionary<string, Func<T,string>>（每个参数一个选择器）或ILookup<string, Func<T,string>>（每个参数一个或多个选择器）。

此时，代码将开始看起来非常粗糙，因为您必须在每次调用扩展方法之前构建字典，因此第一个选项因其清晰度和相对简洁性而变得更具吸引力。

Answer 3

如果您正在研究组合表达式，可以通过PredicateBuilder-ep>来完成

 public static IEnumerable<T> MyMethod<T>(this IEnumerable<T> entity, string param, params Func<T, string>[] selectors) {
    var expression = PredicateBuilder.Make<T>(t => true);
    foreach(var selector in selectors) {
      expression = PredicateBuilder.And<T>(expression,
        l =>
        System.Data.Objects.SqlClient.SqlFunctions.PatIndex(param, "%", selector(l)) > 0);
    }

    return entity.AsQueryable().Where(expression).AsEnumerable();
 }

public static class PredicateBuilder {
  public static Expression<Func<T, bool>> Make<T>() {
    return null;
  }

  public static Expression<Func<T, bool>> Make<T>(this Expression<Func<T, bool>> predicate) {
    return predicate;
  }

  public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> orExpression) {
    if (expr == null) {
      return orExpression;
    }
    var invokedExpr = Expression.Invoke(orExpression, expr.Parameters.Cast<Expression>());
    return Expression.Lambda<Func<T, bool>>(Expression.Or(expr.Body, invokedExpr), expr.Parameters);
  }

  public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> andExpression) {
    if (expr == null) {
      return andExpression;
    }
    var invokedExpr = Expression.Invoke(andExpression, expr.Parameters.Cast<Expression>());
    return Expression.Lambda<Func<T, bool>>(Expression.And(expr.Body, invokedExpr), expr.Parameters);
  }
}

Func <t，string =“”>有多个参数</t，>

3 个答案: