是否可以更改Func <T, bool>委托的泛型类型参数？

Question

我想这个问题的答案是'不'，但无论如何。

基本上，我有一个Linq2Sql数据提供者及其生成的类型。我也有业务对象，其属性名称（为了这个问题）完全匹配其相关的生成类型的属性名称。业务类型在整个应用程序中使用，生成的类型仅用于访问数据库 - 由于多种原因，此设置是可取的，所以请不要建议需要对此进行任何更改的答案。

在UI层中，有各种控件可以让用户调整搜索的方式，例如。搜索字词等。使用这些控件，我可以创建一个不错的Func<T, bool>委托来封装搜索条件/查询。我的问题是Func委托是使用T类型参数作为业务对象创建的，当它传递给数据访问层时，我需要它是相关的生成类型。

所以我的问题是，是否可以将Func委托的泛型类型参数从业务对象类型更改为相关的生成类型，同时保持相同的条件？

eg. can Func<MasterTrack, bool> => Func<DbMasterTrack, bool> when properties match? 

还请注意，我可以只通过所有的用户选择的搜索参数对数据访问层的，但也有相当多的人，所以我希望能避免这种情况。

Answer 1

我不相信这是可能的，但你可以逃脱执行以下操作：

• 让DbMasterTrack隐式转换为MasterTrack;
• 查询时只是将Func<MasterTack,bool>换成Func<DbMasterTrack,bool>。

我也有需要注意的是，如果你使用的是Func<T, bool>，而不是Expression<Func<T, bool>，你不是真的过滤结果集在数据库级别，但可能是你已经知道的东西。

实施例如下：

class MasterTrack 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 
class DbMasterTrack 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public static implicit operator MasterTrack(DbMasterTrack @this) 
    { 
     return new MasterTrack { Id = @this.Id, Name = @this.Name }; 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     var tracks = new List<DbMasterTrack> 
     { 
      new DbMasterTrack { Id = 1, Name = "T1" }, 
      new DbMasterTrack { Id = 2, Name = "T2" }, 
     }; 

     Func<MasterTrack, bool> query = t => t.Id == 1; 

     var result = tracks.Where((Func<DbMasterTrack, bool>)(t => query(t))); 

     foreach (var item in result) 
     { 
      Console.WriteLine("{0}|{1}", item.Id, item.Name); 
     } 
    } 
} 

Answer 2

几件事情

1. LINQ2SQL也可以使用Expression<Func<T, bool>>代替Func<T, bool>。

2. 这是不可能的变化的Expression<Func<T, bool>>

3. 是可以复制/重新创建一个Expression<Func<T, bool>>，你用另一种类型的替代类型T的类型。

4. Linq2Sql将不是在其表达式中接受接口类型。所以如果你考虑创建接口来'抽象'实际的类型，那就行不通了。

现在，创建从Expression<Func<T, bool>>的Expression<Func<T2, bool>>有一次，我创建了下面的代码。它不是“完整的”，因为不支持表达式中所有可能的路径。但是，您检查值的属性（<> =！=或组合）的基本和/或组合工作正常。

使用此代码，你可以这样做：

Expression<Func<MasterTrack, bool>> criteria = m => m.Id == 1; 
Expression<Func<DbMasterTrack, bool>> dbCriteria = ExpressionRewriter.CastParam<MasterTrack, DbMasterTrack>(criteria); 

在这里，我们走了。

public static class ExpressionRewriter { 
    /// <summary> 
    /// Casts the param of an expression. 
    /// </summary> 
    /// <typeparam name="TIn">The type of the in.</typeparam> 
    /// <typeparam name="TOut">The type of the out.</typeparam> 
    /// <param name="inExpr">The in expr.</param> 
    /// <returns></returns> 
    public static Expression<Func<TOut, bool>> CastParam<TIn, TOut>(Expression<Func<TIn, bool>> inExpr) { 
     if (inExpr.NodeType == ExpressionType.Lambda && 
      inExpr.Parameters.Count > 0) { 

      var inP = inExpr.Parameters[0]; 
      var outP = Expression.Parameter(typeof(TOut), inP.Name); 

      var outBody = Rewrite<TIn, TOut>(
       inExpr.Body, 
       expr => (expr is ParameterExpression) ? outP : expr 
      ); 
      return Expression.Lambda<Func<TOut, bool>>(
        outBody, 
        new ParameterExpression[] { outP }); 
     } else { 
      throw new NotSupportedException(); 
     } 
    } 

    /// <summary> 
    /// Rewrites the specified expression. 
    /// </summary> 
    /// <typeparam name="TIn">The type of the in.</typeparam> 
    /// <typeparam name="TOut">The type of the out.</typeparam> 
    /// <param name="exp">The exp.</param> 
    /// <param name="c">The c.</param> 
    /// <returns></returns> 
    private static Expression Rewrite<TIn, TOut>(Expression exp, Func<Expression, Expression> c) { 
     Expression clone = null; 
     var be = exp as BinaryExpression; 
     switch (exp.NodeType) { 
      case ExpressionType.AndAlso: 
       clone = Expression.AndAlso(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.Method); 
       break; 
      case ExpressionType.OrElse: 
       clone = Expression.OrElse(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.Method); 
       break; 
      case ExpressionType.Equal: 
       clone = Expression.Equal(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.IsLiftedToNull, be.Method); 
       break; 
      case ExpressionType.GreaterThan: 
       clone = Expression.GreaterThan(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.IsLiftedToNull, be.Method); 
       break; 
      case ExpressionType.GreaterThanOrEqual: 
       clone = Expression.GreaterThanOrEqual(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.IsLiftedToNull, be.Method); 
       break; 
      case ExpressionType.LessThan: 
       clone = Expression.LessThan(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.IsLiftedToNull, be.Method); 
       break; 
      case ExpressionType.LessThanOrEqual: 
       clone = Expression.LessThanOrEqual(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.IsLiftedToNull, be.Method); 
       break; 
      case ExpressionType.NotEqual: 
       clone = Expression.NotEqual(Rewrite<TIn, TOut>(be.Left, c), Rewrite<TIn, TOut>(be.Right, c), be.IsLiftedToNull, be.Method); 
       break; 
      case ExpressionType.Not: 
       var ue = exp as UnaryExpression; 
       clone = Expression.Not(Rewrite<TIn, TOut>(ue.Operand, c)); 
       break; 
      case ExpressionType.MemberAccess: 
       var me = exp as MemberExpression; 

       MemberInfo newMember = me.Member; 
       Type newType = newMember.DeclaringType; 
       if (newType == typeof(TIn)) { 
        newType = typeof(TOut); 
        MemberInfo[] members = newType.GetMember(me.Member.Name); 
        if (members.Length == 1) { 
         newMember = members[0]; 
        } else { 
         throw new NotSupportedException(); 
        } 
       } 
       clone = Expression.MakeMemberAccess(Rewrite<TIn, TOut>(me.Expression, c), newMember); 
       break; 
      case ExpressionType.Constant: 
       var ce = exp as ConstantExpression; 
       clone = Expression.Constant(ce.Value); 
       break; 
      case ExpressionType.Parameter: 
       var pe = exp as ParameterExpression; 
       Type peNewType = pe.Type; 
       if (peNewType == typeof(TIn)) { 
        peNewType = typeof(TOut); 
       } 
       clone = Expression.Parameter(peNewType, pe.Name); 
       break; 
      case ExpressionType.Call: 
       MethodCallExpression mce = exp as MethodCallExpression; 
       if (mce.Arguments != null && mce.Arguments.Count > 0) { 
        List<Expression> expressionList = new List<Expression>(); 
        foreach (Expression expression in mce.Arguments) { 
         expressionList.Add(Rewrite<TIn, TOut>(expression, c)); 
        } 
        clone = Expression.Call(Rewrite<TIn, TOut>(mce.Object, c), mce.Method, expressionList.ToArray()); 
       } else { 
        clone = Expression.Call(Rewrite<TIn, TOut>(mce.Object, c), mce.Method); 
       } 
       break; 
      case ExpressionType.Invoke: 
       InvocationExpression ie = exp as InvocationExpression; 
       List<Expression> arguments = new List<Expression>(); 
       foreach (Expression expression in ie.Arguments) { 
        arguments.Add(Rewrite<TIn, TOut>(expression, c)); 
       } 
       clone = Rewrite<TIn, TOut>(ie.Expression, c); 
       //clone = Expression.Invoke(Rewrite<TIn, TOut>(ie.Expression, c), arguments); 
       break; 
      case ExpressionType.Convert: 
       var ue2 = exp as UnaryExpression; 
       //clone = Expression.Not(Rewrite<TIn, TOut>(ue2.Operand, c)); 
       clone = Expression.Convert(ue2.Operand, ue2.Type, ue2.Method); 
       break; 
      default: 
       throw new NotImplementedException(exp.NodeType.ToString()); 
     } 
     return c(clone); 
    } 
}