在 LINQ 中使用自定义表达式会导致每次使用都进行查询

Question

我遇到以下问题：在我们的数据库中，我们记录服务台票证，并在票证下预订时间。中间是一份访问报告。所以是：票=>访问报告=>小时。

小时有一定的“种类”，它不是由小时记录中的类型指示符确定的，而是通过检查小时的各种属性来编译的。例如，有客户但不是服务时间的小时始终是发票时间。

我最不想要的就是这些“种类”的定义在代码中随处可见。他们一定在一个地方。其次，我希望能够从各种小时集合中计算总小时数。例如，具有特定日期和特定客户的门票的扁平化集合。或者所有标记为“解决方案”的注册。

我决定使用“分层”数据库访问方法。相同的函数可以为屏幕表示提供数据，也可以为 .pdf 格式的报告提供数据。因此，第一步收集所有相关数据。它可用于 .pdf 创建，也可用于屏幕表示。在这种情况下，必须在第二步中对其进行分页和排序。这样我就不需要基本上使用相同数据的单独查询。

数据量可能很大，例如创建年份总计。因此第一步的数据应该是可查询的，而不是可枚举的。为了确保即使在结果中添加小时总和时也保持可查询性，我创建了以下函数：

    public static decimal TreeHours(this IEnumerable<Uren> h, FactHourType ht)
{
    IQueryable<Uren> hours = h.AsQueryable();
    ParameterExpression pe = Expression.Parameter(typeof(Uren), "Uren");
    Expression left = Expression.Property(pe, typeof(Uren).GetProperty("IsOsab"));
    Expression right = Expression.Constant(true, typeof(Boolean));
    Expression isOsab = Expression.Equal(Expression.Convert(left, typeof(Boolean)), Expression.Convert(right, typeof(Boolean)));

    left = Expression.Property(pe, typeof(Uren).GetProperty("IsKlant"));
    right = Expression.Constant(true, typeof(Boolean));
    Expression isCustomer = Expression.Equal(Expression.Convert(left, typeof(Boolean)), Expression.Convert(right, typeof(Boolean)));
    Expression notOsab;
    Expression notCustomer;
    Expression final;
    switch (ht)
    {
        case FactHourType.Invoice:
            notOsab = Expression.Not(isOsab);
            final = Expression.And(notOsab, isCustomer);
            break;
        case FactHourType.NotInvoice:
            notOsab = Expression.Not(isOsab);
            notCustomer = Expression.Not(isCustomer);
            final = Expression.And(notOsab, notCustomer);
            break;
        case FactHourType.OSAB:
            final = Expression.And(isOsab, isCustomer);
            break;
        case FactHourType.OsabInvoice:
            final = Expression.Equal(isCustomer, Expression.Constant(true, typeof(Boolean)));
            break;
        case FactHourType.Total:
            final = Expression.Constant(true, typeof(Boolean));
            break;
        default:
            throw new Exception("");
    }
    MethodCallExpression whereCallExpression = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { hours.ElementType },
hours.Expression,
Expression.Lambda<Func<Uren, bool>>(final, new ParameterExpression[] { pe })
);
    IQueryable<Uren> result = hours.Provider.CreateQuery<Uren>(whereCallExpression);
    return result.Sum(u => u.Uren1);

}

该函数背后的想法是它应该保持可查询性，这样我就不会将大量数据切换为可枚举。

我设法保持可查询性直到最后。在步骤 1 中，我收集原始数据。在步骤 2 中，我对数据进行排序，然后对其进行分页。在第3步中，数据被转换为JSon并发送到客户端。按票计算总计小时数。

问题是：我收到一个关于每张票的营业时间的查询。这是数百个查询！太多了...

我尝试了以下方法：

DataLoadOptions options = new DataLoadOptions();
options.LoadWith<Ticket>(t => t.Bezoekrapport);
options.LoadWith<Bezoekrapport>(b => b.Urens);
dc.LoadOptions = options;

Bezoekrapport 在荷兰语中是“访问报告”的意思。当我查看检索票证的查询时，我看到它加入了 Bezoekrapport/visitreport，但没有加入附加的时间。

我使用的第二种方法是在 LINQ 中手动加入时间，但这效果不佳。

我一定做错了什么。这里最好的方法是什么？

以下代码片段是我检索数据的方式。在最后一步中对 strHours 调用 toList() 时，我收到了大量查询。我已经尝试了两天来解决这个问题，但它就是不起作用......我的方法或 TreeHours 函数一定有问题。

步骤 1：

IQueryable<RelationHoursTicketItem> HoursByTicket =
            from Ticket t in allTickets
            let RemarkSolved = t.TicketOpmerkings.SingleOrDefault(tr => tr.IsOplossing)
            let hours = t.Bezoekrapport.Urens.
                Where(h =>
                      (dateFrom == null || h.Datum >= dateFrom)
                      && (dateTo == null || h.Datum <= dateTo)
                      && h.Uren1 > 0)
            select new RelationHoursTicketItem
                       {
                           Date = t.DatumCreatie,
                           DateSolved = RemarkSolved == null ? (DateTime?)null :                                                                                              RemarkSolved.Datum,
                           Ticket = t,
                           Relatie = t.Relatie,
                           HoursOsab = hours.TreeHours(FactHourType.OSAB),
                           HoursInvoice = hours.TreeHours(FactHourType.Invoice),
                           HoursNonInvoice = hours.TreeHours(FactHourType.NotInvoice),
                           HoursOsabInvoice = hours.TreeHours(FactHourType.OsabInvoice),
                           TicketNr = t.Id,
                           TicketName = t.Titel,
                           TicketCategorie = t.TicketCategorie,
                           TicketPriority = t.TicketPrioriteit,
                           TicketRemark = RemarkSolved
                       };

步骤 2

        sort = sort ?? "TicketNr";
        IQueryable<RelationHoursTicketItem> hoursByTicket = GetRelationHours(relation,     dateFrom, dateTo, withBranches);
        IOrderedQueryable<RelationHoursTicketItem> orderedResults;

        if (dir == "ASC")
        {
            orderedResults = hoursByTicket.OrderBy(sort);
}
        else
        {
            orderedResults = hoursByTicket.OrderByDescending(sort);
        }
        IEnumerable<RelationHoursTicketItem> pagedResults = orderedResults.Skip(start ?? 0).Take(limit ?? 25);
        records = hoursByTicket.Count();
        return pagedResults;

步骤 3：

 IEnumerable<RelationHoursTicketItem> hours = _hourReportService.GetRelationReportHours(relation, dateFrom, dateTo, metFilialen, start, limit, dir, sort, out records);

        var strHours = hours.Select(h => new
               {
                   h.TicketNr,
                   h.TicketName,
                   RelationName = h.Relatie.Naam,
                   h.Date,
                   TicketPriority = h.TicketPriority.Naam,
                   h.DateSolved,
                   TicketCategorie = h.TicketCategorie == null ? "" : h.TicketCategorie.Naam,
                   TicketRemark = h.TicketRemark == null ? "" : h.TicketRemark.Opmerking,
                   h.HoursOsab,
                   h.HoursInvoice,
                   h.HoursNonInvoice,
                   h.HoursOsabInvoice
               });

Answer 1

我不认为您的 TreeHours 扩展方法可以通过 LINQ 一次性转换为 SQL。因此，在行的每个构造函数的执行上进行评估，在本例中每行导致对数据库的 4 次调用。

我将简化您的 LINQ 查询，以从 SQL 返回原始数据，使用简单的 JOIN 来获取所有门票和营业时间。然后，我会按内存中的类型对小时进行分组和过滤。否则，如果您确实需要在 SQL 中执行操作，请查看 CompiledQuery.Compile 方法。这应该能够处理不进行每行查询的情况。我不确定您是否会在其中找到 switch，但您也许可以使用 ?: 运算符对其进行转换。