Можно ли изменить параметр универсального типа делегата Func‹T, bool›?

Я не верю, что это возможно, но вы можете уйти, выполнив следующие действия:

• Сделать 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);
        }
    }
}

Пара вещей

1. Linq2Sql также может использовать Expression<Func<T, bool>> вместо Func<T, bool>.

2. Невозможно изменить тип Expression<Func<T, bool>>

3. Можно ли скопировать/воссоздать Expression<Func<T, bool>>, где вы замените тип T другим типом.

4. Linq2Sql НЕ будет принимать тип интерфейса в своем выражении. Поэтому, если вы думаете о создании интерфейсов для «абстракции» фактического типа, это не сработает.

Теперь, чтобы создать Expression<Func<T2, bool>> из Expression<Func<T, 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);
    }
}