Question

我正在使用LINQ-＆gt; WCF数据服务 - ＆gt; EF，它支持LINQ的一个子集，但有一些注意事项。一旦学习了各种各样的技巧和解决方法，我就没有遇到过这个问题，但是我想制作一个可重用的表达式生成器，用于仅比较Date的{{1}}部分。

使用常规EF，您可以使用DateTime（EF <6）或EntityFunctions.TruncateTime（EF6 +），但这不适用于数据服务。

到目前为止，我的解决方案是反复构建where where子句：

DbFunctions.TruncateTime

不得不重复写（但它确实有效），这是令人讨厌的，所以我试图创造类似的东西：

.Where(x => x.DateProperty.Year == DateToCompare.Year && 
            x.DateProperty.Month == DateToCompare.Month && 
            x.DateProperty.Day == DateToCompare.Day);

任何类似的东西都会做，只是简短，甜蜜和可读 - 我厌恶重复的不必要的感觉代码。

结构不是问题，我知道我需要一些需要.WhereDate(x => x.DateProperty, DateToCompare);，IQueryable<T>（或Func<T, DateTime>）和Expression<Func<T, DateTime>>并返回DateTime的内容}。

IQueryable<T>

我遇到麻烦的是接受这个并构建一个可以放入where子句的表达式而不违反表达式树的限制。我不完全确定如何获取现有查询并将我自己的where语句添加到表达式而不执行public static IQueryable<T> WhereDate<T>(this IQueryable<T> data, Func<T, DateTime>> selector, DateTime date) { return data.Where(/*Something*/); };，我认为这可能是关键。我想我需要接受一个.Where并构建一些使用它来添加Expression<Func<T, DateTime>> IQueryable`的东西。

任何人都有这方面的经验，或者知道我应该阅读哪些文档？

这里最大的障碍是您无法将基于语句的lambda转换为表达式，并且您无法将不支持的函数传递到数据服务或 EF。这使得所有天真的解决方案都变得不可能，据我所知，这会留下手动表达式操作。

Answer 1

这是我在阅读了很多关于这个主题后提出的解决方案：

private static IQueryable<T> _whereDate<T>(this IQueryable<T> data, MemberExpression date1Expression, ParameterExpression parameter, DateTime date)
{
    var date1Year = Expression.Property(date1Expression, "Year");
    var date1Month = Expression.Property(date1Expression, "Month");
    var date1Day = Expression.Property(date1Expression, "Day");
    var date2Year = Expression.Constant(date.Year);
    var date2Month = Expression.Constant(date.Month);
    var date2Day = Expression.Constant(date.Day);
    var yearsEqual = Expression.Equal(date1Year, date2Year);
    var monthsEqual = Expression.Equal(date1Month, date2Month);
    var daysEqual = Expression.Equal(date1Day, date2Day);
    var allPartsEqual = Expression.AndAlso(Expression.AndAlso(daysEqual, monthsEqual), yearsEqual); //Day->Month->Year to efficiently remove as many as possible as soon as possible.
    var whereClause = Expression.Call(typeof(Queryable), "Where", new Type[] { data.ElementType }, data.Expression, Expression.Lambda(allPartsEqual, parameter));
    return data.Provider.CreateQuery<T>(whereClause);
}

public static IQueryable<T> WhereDate<T>(this IQueryable<T> data, Expression<Func<T, DateTime?>> selector, DateTime date)
{
    var selectorMemberExpression = ((MemberExpression)selector.Body);
    var nullableDateProperty = (PropertyInfo)selectorMemberExpression.Member;
    var entityExpression = Expression.Parameter(typeof(T));
    var date1Expression = Expression.Property(entityExpression, nullableDateProperty);
    return data._whereDate(Expression.PropertyOrField(date1Expression, "Value"), entityExpression, date);
}

public static IQueryable<T> WhereDate<T>(this IQueryable<T> data, Expression<Func<T, DateTime>> selector, DateTime date)
{
    var selectorMemberExpression = ((MemberExpression)selector.Body);
    var dateProperty = (PropertyInfo)selectorMemberExpression.Member;
    var entityExpression = Expression.Parameter(typeof(T));
    return data._whereDate(Expression.Property(entityExpression, dateProperty), entityExpression, date);
}

它分为多个功能，以减少冗余代码并支持DateTime和DateTime?。

我意识到可以对可空版本缺乏价值进行检查 - 这是我很快就会添加的内容，但我想让其他人学习解决方案来自并确保没有人浪费时间向我解释这一点。我总是通过几次代码来提高效率和可读性，记录函数，评论不清楚的事情，确保不会出现意外的Exception，但事先就是这样。如果您逐字使用此代码，请记住这一点（如果您这样做，请告诉我，我想知道我没有浪费时间来发布此代码）。

Answer 2

您始终可以使用System.Linq.Expressions.Expression类方法构建所需的表达式。然而，这很烦人，很棘手且容易出错。

相反，您可以使用编译时原型表达式，使用我为Entity Framework + DayOfWeek的答案创建的小助手实用程序将参数替换为实际值：

public static class ExpressionUtils
{
    public static Expression<Func<TResult>> Expr<TResult>(Expression<Func<TResult>> e) => e;
    public static Expression<Func<T, TResult>> Expr<T, TResult>(Expression<Func<T, TResult>> e) => e;
    public static Expression<Func<T1, T2, TResult>> Expr<T1, T2, TResult>(Expression<Func<T1, T2, TResult>> e) => e;
    public static Expression<Func<T1, T2, T3, TResult>> Expr<T1, T2, T3, TResult>(Expression<Func<T1, T2, T3, TResult>> e) => e;
    public static Expression<Func<T1, T2, T3, T4, TResult>> Expr<T1, T2, T3, T4, TResult>(Expression<Func<T1, T2, T3, T4, TResult>> e) => e;
    public static Expression WithParameters(this LambdaExpression expression, params Expression[] values)
    {
        return expression.Parameters.Zip(values, (p, v) => new { p, v })
            .Aggregate(expression.Body, (e, x) => e.ReplaceParameter(x.p, x.v));
    }
    public static Expression ReplaceParameter(this Expression expression, ParameterExpression source, Expression target)
    {
        return new ParameterReplacer { Source = source, Target = target }.Visit(expression);
    }
    class ParameterReplacer : ExpressionVisitor
    {
        public ParameterExpression Source;
        public Expression Target;
        protected override Expression VisitParameter(ParameterExpression node)
        {
            return node == Source ? Target : base.VisitParameter(node);
        }
    }
}

这个想法很简单。您可以使用参数

创建原型lambda表达式

var protoExpr = ExpressionUtils.Expr((DateTime x, DateTime y) =>
    x.Year == y.Year && x.Month == y.Month && x.Day == y.Day);

然后用实际表达式替换参数。

var actualExpr = protoExpr.WithParameters(expr1, expr2);

例如，有问题的方法可以这样实现：

public static class WcfQueryableExtensions
{
    public static IQueryable<T> WhereEqual<T>(this IQueryable<T> source, Expression<Func<T, DateTime>> selector, DateTime date)
    {
        var dateValue = ExpressionUtils.Expr(() => date).Body;
        var predicate = Expression.Lambda<Func<T, bool>>(
            ExpressionUtils.Expr((DateTime x, DateTime y) =>
                x.Year == y.Year && x.Month == y.Month && x.Day == y.Day)
                .WithParameters(selector.Body, dateValue),
            selector.Parameters);
        return source.Where(predicate);
    }
}

但是，还有更通用的方法，它也适用于查询语法。您使用自然的LINQ to Objects样式（使用CLR方法/属性/运算符）编写查询，然后使用单个扩展方法将查询转换为WCF兼容格式。该方法本身将使用ExpressionVistor来重写查询表达式。例如，这是实现DateTime相等的起始点：

public static class WcfQueryableExtensions
{
    public static IQueryable<T> AsWcfQueryable<T>(this IQueryable<T> source)
    {
        var expression = new WcfConverter().Visit(source.Expression);
        if (expression == source.Expression) return source;
        return source.Provider.CreateQuery<T>(expression);
    }

    class WcfConverter : ExpressionVisitor
    {
        protected override Expression VisitBinary(BinaryExpression node)
        {
            if (node.NodeType == ExpressionType.Equal && node.Left.Type == typeof(DateTime))
                return ExpressionUtils.Expr((DateTime x, DateTime y) =>
                    x.Year == y.Year && x.Month == y.Month && x.Day == y.Day)
                    .WithParameters(Visit(node.Left), Visit(node.Right));
            return base.VisitBinary(node);
        }
    }
}

您可以在需要时相对轻松地添加其他转化。它可以在上述方法中，也可以通过拦截链接帖子中的其他Visit方法。

样本用法：

var query = (from x in myQueryable
             where x.DateProperty == DateToCompare
             ...
             select ...
             ).AsWcfQueryable()

为IQueryable <t>生成表达式

2 个答案: