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

时间:2013-06-14 14:58:40

标签: c# asp.net entity-framework

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();

3 个答案:

答案 0 :(得分:4)

您可以使用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解决方案。

答案 1 :(得分:1)

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

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>>(每个参数一个或多个选择器)。

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

答案 2 :(得分:1)

如果您正在研究组合表达式,可以通过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);
  }
}