实体框架+ DayOfWeek

本文关键字：DayOfWeek 框架 实体 | 更新日期: 2023-09-27 18:15:01

使用System.Linq.Dynamic(在这里管理https://github.com/kahanu/System.Linq.Dynamic)，我试图捕获DateTime上发现的DayOfWeek字段，用于使用实体框架6(或更高版本)进行聚合。

以前问过类似的东西，这帮助了很多，动态Linq +实体框架:动态选择的日期时间修改

实体框架支持使用

获取DayOfWeek
SqlFunctions.DatePart("dw", datetime?)

或者我们可以用

这样更理想的方式
DbFunctions.DiffDays(date?, date?).

的想法:

在Linq中获取DayOfWeek

我发现这很有趣，我喜欢它，因为它不使用SqlFunctions，这可能会让我局限于SQL Server。另外，开发人员可以控制一周的第一天是什么，而不必查询SQL Server属性来查找其配置(第一天)。

出于实验目的，我一直试图在VisitMember()覆盖中实现这一点:

protected override Expression VisitMember(MemberExpression node)
{
     if (node.Type == typeof(System.DayOfWeek))
     {
          var firstSunday = new DateTime(1753, 1, 7);
                var firstSundayExpression = Expression.Constant(firstSunday, typeof(DateTime?));
                var timeValue = node.Expression;
                if (timeValue.Type != typeof(DateTime?)) timeValue = Expression.Convert(timeValue, typeof(DateTime?));
                var methodCall = Expression.Call(
                              typeof(DbFunctions), "DiffDays", Type.EmptyTypes, firstSundayExpression, timeValue);
                return Expression.Convert(methodCall, typeof(int?));
      }
      return base.VisitMember(node);
 }

使用上面的想法，我认为我可以包装这个表达式，然后将模值应用于输入时间，但我甚至不能让这个表达式更进一步。

我觉得我错过了表达式是如何构建的一个基本部分。使用

得到的错误

参数类型不匹配

在System.Linq.Expressions.Expression

。Bind(MemberInfo member, Expression Expression)
在System.Linq.Expressions.ExpressionVisitor。访问[T](ReadOnlyCollection 1 nodes, Func 2 elementVisitor)
在System.Linq.Expressions.ExpressionVisitor。VisitMemberInit (MemberInitExpression节点)
在System.Linq.Expressions.ExpressionVisitor。VisitLambda [T](表达式' 1节点)
在System.Linq.Expressions.ExpressionVisitor。VisitUnary (UnaryExpression节点)
在System.Linq.Expressions.ExpressionVisitor。VisitArguments (IArgumentProvider节点)
在System.Linq.Expressions.ExpressionVisitor。VisitMethodCall (MethodCallExpression节点)
在QueryableExtensions.DbFunctionsBinder。VisitMethodCall(methodcalexpression节点)在路径'QueryableExtensions.cs:第48行
在BindDbFunctions(IQueryable源)路径'QueryableExtensions.cs:第13行
在Path'AggregateHelper.cs:line 811

——从抛出异常的前一个位置开始的堆栈跟踪结束

在System.Runtime.CompilerServices.TaskAwaiter

。ThrowForNonSuccess(工作任务)
在System.Runtime.CompilerServices.TaskAwaiter。HandleNonSuccessAndDebuggerNotification(工作任务)
getresult 1. System.Runtime.CompilerServices.TaskAwaiter’()
在路径'AggregationPluginServiceHelper.cs:第199行

我知道我可以做到这一点，因为我写了内联编译的查询。这很好。但是这是特别使用动态库的。

示例用法如下:

var grouping = select.GroupBy("new (DateTimeColumn.DayOfWeek)", "it");

有更好的方法来获得一周中的一天吗?我知道这可能是文化上的不同，所以做天数与周日不同的模数(上面的链接想法)我相信是正确的方法。

实体框架+ DayOfWeek

基本上你需要转换一个表达式，比如

expr.DayOfWeek


var firstSunday = new DateTime(1753, 1, 7);
(DayOfWeek)(((int)DbFunctions.DiffDays((DateTime?)firstSunday, (DateTime?)expr)) % 7)

你可以这样做:

protected override Expression VisitMember(MemberExpression node)
{
    if (node.Type == typeof(DayOfWeek))
    {
        var expr = node.Expression;
        var firstSunday = new DateTime(1753, 1, 7);
        var diffDays = Expression.Convert(
            Expression.Call(
                typeof(DbFunctions), "DiffDays", Type.EmptyTypes,
                Expression.Constant(firstSunday, typeof(DateTime?)),
                Expression.Convert(expr, typeof(DateTime?))),
            typeof(int));
        var dayOfWeek = Expression.Convert(
            Expression.Modulo(diffDays, Expression.Constant(7)),
            typeof(DayOfWeek));
        return dayOfWeek;
    }
    return base.VisitMember(node);
}

Update:这个过程可以通过使用编译时原型表达式来简化，使用一个小的辅助实用程序将参数替换为实际值:

public static class ExpressionUtils
{
    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);
        }
    }
}

这与c# 6的静态导入特性相结合，使实现更加简单和可读。

例如:

using static System.Linq.Expressions.Expression;
using static ExpressionUtils;

所讨论的方法现在看起来像这样:

protected override Expression VisitMember(MemberExpression node)
{
    if (node.Type == typeof(DayOfWeek))
    {
        return Expr((DateTime dateValue1, DateTime dateValue2) => 
            (DayOfWeek)(DbFunctions.DiffDays(dateValue1, dateValue2).Value % 7))
            .WithParameters(Constant(new DateTime(1753, 1, 7)), Visit(node.Expression));
    }
    return base.VisitMember(node);
}

和你之前关于AddHours的问题:

protected override Expression VisitMethodCall(MethodCallExpression node)
{
    if (node.Object != null && node.Object.Type == typeof(DateTime))
    {
        if (node.Method.Name == "AddHours")
        {
            return Expr((DateTime timeValue, double addValue) => 
                DbFunctions.AddHours(timeValue, (int)addValue).Value)
                .WithParameters(Visit(node.Object), Visit(node.Arguments[0]));
        }
    }
    return base.VisitMethodCall(node);
}
相关文章：