C# EF 6:查询结果不能枚举多次

如果不使用ToList（），是否有任何方法可以避免“查询结果不能被多次枚举”异常

以下是我的代码的简化版本：

var entities = _db.Trades.Where(t => t.A > 10);
int totalCount = entities.Count();
entities = entities.Where(t => t.B > 10);
int totalCountAfterAdditionalFilter = entities.Count();

出于性能考虑，我无法调用ToList（）。我知道我可以再生成一个IQueryable，但这似乎是错误的（我有更多这样的过滤器）。在第一次调用Count（）之后，我是否可以以某种方式保留/复制IQueryable

---

谢谢

不，你不能像那样达到你想要的结果。但是，您也可以将过滤器保存为变量，然后根据需要组合它们：

 Func<Trade, bool> filter1 = t => t.A > 10;
 Func<Trade, bool> filter2 = t => t => t.B > 10;
 Func<Trade, bool> compositeFilter = t => filter1(t) && filter2(t);

 int totalCount = _db.Trades.Count(filter1);
 int totalCountAfterAdditionalFilter  = _db.Trades.Count(compositeFilter);

 //Need more?
 compositeFilter = t => compositeFilter(t) && t.C > 100;
 int totalAfterMoreFilters = _db.Trades.Count(compositeFilter);

Func filter1=t=>t.A>10；
Func filter2=t=>t=>t.B>10；
Func compositeFilter=t=>filter1（t）和&filter2（t）；
int totalCount=_db.Trades.Count（filter1）；
int totalCountAfterAdditionalFilter=_db.Trades.Count（复合过滤器）；
//需要更多吗？
复合滤波器=t=>compositeFilter（t）和&t.C>100；
int totalAfterMoreFilters=_db.Trades.Count（复合过滤器）；

不，你不能像那样达到你想要的结果。但是，您也可以将过滤器保存为变量，然后根据需要组合它们：

 Func<Trade, bool> filter1 = t => t.A > 10;
 Func<Trade, bool> filter2 = t => t => t.B > 10;
 Func<Trade, bool> compositeFilter = t => filter1(t) && filter2(t);

 int totalCount = _db.Trades.Count(filter1);
 int totalCountAfterAdditionalFilter  = _db.Trades.Count(compositeFilter);

 //Need more?
 compositeFilter = t => compositeFilter(t) && t.C > 100;
 int totalAfterMoreFilters = _db.Trades.Count(compositeFilter);

Func filter1=t=>t.A>10；
Func filter2=t=>t=>t.B>10；
Func compositeFilter=t=>filter1（t）和&filter2（t）；
int totalCount=_db.Trades.Count（filter1）；
int totalCountAfterAdditionalFilter=_db.Trades.Count（复合过滤器）；
//需要更多吗？
复合滤波器=t=>compositeFilter（t）和&t.C>100；
int totalAfterMoreFilters=_db.Trades.Count（复合过滤器）；

不，你不能像那样达到你想要的结果。但是，您也可以将过滤器保存为变量，然后根据需要组合它们：

 Func<Trade, bool> filter1 = t => t.A > 10;
 Func<Trade, bool> filter2 = t => t => t.B > 10;
 Func<Trade, bool> compositeFilter = t => filter1(t) && filter2(t);

 int totalCount = _db.Trades.Count(filter1);
 int totalCountAfterAdditionalFilter  = _db.Trades.Count(compositeFilter);

 //Need more?
 compositeFilter = t => compositeFilter(t) && t.C > 100;
 int totalAfterMoreFilters = _db.Trades.Count(compositeFilter);

Func filter1=t=>t.A>10；
Func filter2=t=>t=>t.B>10；
Func compositeFilter=t=>filter1（t）和&filter2（t）；
int totalCount=_db.Trades.Count（filter1）；
int totalCountAfterAdditionalFilter=_db.Trades.Count（复合过滤器）；
//需要更多吗？
复合滤波器=t=>compositeFilter（t）和&t.C>100；
int totalAfterMoreFilters=_db.Trades.Count（复合过滤器）；

不，你不能像那样达到你想要的结果。但是，您也可以将过滤器保存为变量，然后根据需要组合它们：

 Func<Trade, bool> filter1 = t => t.A > 10;
 Func<Trade, bool> filter2 = t => t => t.B > 10;
 Func<Trade, bool> compositeFilter = t => filter1(t) && filter2(t);

 int totalCount = _db.Trades.Count(filter1);
 int totalCountAfterAdditionalFilter  = _db.Trades.Count(compositeFilter);

 //Need more?
 compositeFilter = t => compositeFilter(t) && t.C > 100;
 int totalAfterMoreFilters = _db.Trades.Count(compositeFilter);

Func filter1=t=>t.A>10；
Func filter2=t=>t=>t.B>10；
Func compositeFilter=t=>filter1（t）和&filter2（t）；
int totalCount=_db.Trades.Count（filter1）；
int totalCountAfterAdditionalFilter=_db.Trades.Count（复合过滤器）；
//需要更多吗？
复合滤波器=t=>compositeFilter（t）和&t.C>100；
int totalAfterMoreFilters=_db.Trades.Count（复合过滤器）；

可能是：

Trades.Where(x => x.A > 10).Select(x => new { i = 1, j = x.B > 10 ? 1 : 0}).
    GroupBy(y => y.i).
    Select(g => new { c = g.Count(), = g.Sum(z => z.j)})

这将在一个查询中为您提供两个信息。

可能是：

Trades.Where(x => x.A > 10).Select(x => new { i = 1, j = x.B > 10 ? 1 : 0}).
    GroupBy(y => y.i).
    Select(g => new { c = g.Count(), = g.Sum(z => z.j)})

这将在一个查询中为您提供两个信息。

可能是：

Trades.Where(x => x.A > 10).Select(x => new { i = 1, j = x.B > 10 ? 1 : 0}).
    GroupBy(y => y.i).
    Select(g => new { c = g.Count(), = g.Sum(z => z.j)})

这将在一个查询中为您提供两个信息。

可能是：

Trades.Where(x => x.A > 10).Select(x => new { i = 1, j = x.B > 10 ? 1 : 0}).
    GroupBy(y => y.i).
    Select(g => new { c = g.Count(), = g.Sum(z => z.j)})

---

---

这在一个查询中为您提供了两个信息。

“由于性能考虑，我无法调用

ToList（）

”什么性能考虑？查询将需要在某个时候具体化-为什么不在

列表中呢。在这个阶段将它们全部载入内存似乎是错误的。在应用最终过滤器之前，我只想获得计数。过滤完成后，我将具体化查询，它将只返回10条左右的记录。您真的需要知道这两个计数，还是只需要知道是否有任何项被过滤掉？您可以只筛选
t.B Servy，在这种情况下，两个计数都是必需的“由于性能考虑，我无法调用
ToList（）
”什么性能考虑？查询将需要在某个时候具体化-为什么不在
列表中呢。在这个阶段将它们全部载入内存似乎是错误的。在应用最终过滤器之前，我只想获得计数。过滤完成后，我将具体化查询，它将只返回10条左右的记录。您真的需要知道这两个计数，还是只需要知道是否有任何项被过滤掉？您可以只筛选
t.B Servy，在这种情况下，两个计数都是必需的“由于性能考虑，我无法调用
ToList（）
”什么性能考虑？查询将需要在某个时候具体化-为什么不在
列表中呢。在这个阶段将它们全部载入内存似乎是错误的。在应用最终过滤器之前，我只想获得计数。过滤完成后，我将具体化查询，它将只返回10条左右的记录。您真的需要知道这两个计数，还是只需要知道是否有任何项被过滤掉？您可以只筛选
t.B Servy，在这种情况下，两个计数都是必需的“由于性能考虑，我无法调用
ToList（）
”什么性能考虑？查询将需要在某个时候具体化-为什么不在
列表中呢。在这个阶段将它们全部载入内存似乎是错误的。在应用最终过滤器之前，我只想获得计数。过滤完成后，我将具体化查询，它将只返回10条左右的记录。您真的需要知道这两个计数，还是只需要知道是否有任何项被过滤掉？您可以只在
t.B Servy上进行筛选，在这种情况下，两个计数都是必需的。对于要使用它们的LINQ to实体，筛选器
Func
s不必包装在
表达式中吗？问题是我有两个以上的筛选器，其中一些筛选器不应该被触发。但我喜欢你的想法。也许我需要找到一种方法来动态生成表达式，将其保存到一个变量中，然后重新使用它。过滤器
Func
s是否必须包装在
expression
中，以便LINQ to实体使用它们？问题是我有两个以上的过滤器，其中一些过滤器不应该被触发。但我喜欢你的身份证