C# 具有where条件的Linq查询-计数项

如何更改此请求：

query = query.Where(item => (from table in context.Table 
                             where table.amount == item.Amount 
                             select table).Count() >= 10);

不使用子查询

（从…中…

我尝试单独创建子查询，以将其与Where条件一起使用：

var subQuery=来自上下文中的表。表选择table.amount

var list=subQuery.ToList（）

但是我不知道在那之后如何使用它，因为

.Count（）

操作

---

谢谢您的评论。

只需将

Count

直接与谓词一起使用即可：

query.Where(item => context.Table.Count(table.amount == item.Amount) >= 10);

---

只需直接对谓词使用

Count

：

query.Where(item => context.Table.Count(table.amount == item.Amount) >= 10);

---

只需直接对谓词使用

Count

：

query.Where(item => context.Table.Count(table.amount == item.Amount) >= 10);

---

只需直接对谓词使用

Count

：

query.Where(item => context.Table.Count(table.amount == item.Amount) >= 10);

这个怎么样：

query = query.Where(item => context.Table
                                   .Count(t => t.amount == item.Amount) >= 10);

或减少往返次数：

var counts = context.Table
                    .GroupBy(t => t.amount)
                    .Select(g => new {amount = g.Key, count = g.Count()});

query = from q in query
        join c in counts
        on q.amount equals c.amount
        where c.count >= 10
        select q;

这个怎么样：

query = query.Where(item => context.Table
                                   .Count(t => t.amount == item.Amount) >= 10);

或减少往返次数：

var counts = context.Table
                    .GroupBy(t => t.amount)
                    .Select(g => new {amount = g.Key, count = g.Count()});

query = from q in query
        join c in counts
        on q.amount equals c.amount
        where c.count >= 10
        select q;

这个怎么样：

query = query.Where(item => context.Table
                                   .Count(t => t.amount == item.Amount) >= 10);

或减少往返次数：

var counts = context.Table
                    .GroupBy(t => t.amount)
                    .Select(g => new {amount = g.Key, count = g.Count()});

query = from q in query
        join c in counts
        on q.amount equals c.amount
        where c.count >= 10
        select q;

这个怎么样：

query = query.Where(item => context.Table
                                   .Count(t => t.amount == item.Amount) >= 10);

或减少往返次数：

var counts = context.Table
                    .GroupBy(t => t.amount)
                    .Select(g => new {amount = g.Key, count = g.Count()});

query = from q in query
        join c in counts
        on q.amount equals c.amount
        where c.count >= 10
        select q;

这个怎么样

var subQuery = (from table in context.Table select table.amount).ToList();

query = query.Where(item => subQuery.Count() >= 10);

这个怎么样

var subQuery = (from table in context.Table select table.amount).ToList();

query = query.Where(item => subQuery.Count() >= 10);

这个怎么样

var subQuery = (from table in context.Table select table.amount).ToList();

query = query.Where(item => subQuery.Count() >= 10);

这个怎么样

var subQuery = (from table in context.Table select table.amount).ToList();

query = query.Where(item => subQuery.Count() >= 10);

---

---

第一条语句中的

query

是什么？@Habib：我假设您正在试图理解这是否是Linq to objects、SQL等？我不确定Count（）是否正确，但其他Linq方法采用了一个表达式，因此您可以潜在地执行query.Where（item=>context.Table.Count（a=>a.amount==item.amount）@Chris，这与linq to objects无关。根据给出的信息，唯一正确的答案是给出的答案。如果我们理解了

query

是如何创建的，我们可以看到如何更好地合并您的子选择。第一句话中的

query

是什么？@Habib：我想你是想知道这是否是linq对于对象、SQL等？我不确定Count（）是否正确，但其他Linq方法采用了一个表达式，因此您可以潜在地执行query.Where（item=>context.Table.Count（a=>a.amount==item.amount）@Chris，这与linq to objects无关。根据给出的信息，唯一正确的答案是给出的答案。如果我们理解了

query

是如何创建的，我们可以看到如何更好地合并您的子选择。第一句话中的

query

是什么？@Habib：我想你是想知道这是否是linq对于对象、SQL等？我不确定Count（）是否正确，但其他Linq方法采用了一个表达式，因此您可以潜在地执行query.Where（item=>context.Table.Count（a=>a.amount==item.amount）@Chris，这与linq to objects无关。根据给出的信息，唯一正确的答案是给出的答案。如果我们理解了

query

是如何创建的，我们可以看到如何更好地合并您的子选择。第一句话中的

query

是什么？@Habib：我想你是想知道这是否是linq对于对象、SQL等？我不确定Count（）是否正确，但其他Linq方法采用了一个表达式，因此您可以潜在地执行query.Where（item=>context.Table.Count（a=>a.amount==item.amount）@Chris，这与linq to objects无关。根据给出的信息，唯一正确的答案是给出的答案。如果我们理解了

query

是如何创建的，我们可以看到如何更好地合并您的子选择。这还不使用子查询吗？事实上，除了使用方法synt之外，这与原始答案不完全相同吗ax而不是查询语法（或其他被调用的语法）？我认为你必须在q上使用

。Amount等于c.Amount

，因为joinIs仍然不使用子查询？事实上，除了使用方法语法而不是查询语法（或其他被调用的语法）之外，这不是与原始语法完全相同吗？我认为你必须在q上使用

。Amount等于c.Amount

，因为join仍然没有使用子查询吗？事实上，除了使用方法语法而不是查询语法（或其他任何被调用的语法）之外，这不是与原始语法完全相同吗？我认为你必须在q上使用

。Amount等于c.Amount

，因为join仍然没有使用子查询吗？事实上，除了使用方法语法而不是查询语法（或其他任何被调用的语法）之外，这不是与原始语法完全相同吗？我认为你必须在q上使用

。Amount等于c.Amount

，因为join仍然没有使用子查询吗？事实上，除了使用方法语法而不是查询语法（或其他任何被调用的语法）之外，这不是与原始语法完全相同吗？这是否仍然不使用子查询？事实上，除了使用方法语法而不是查询语法（或其他被称为查询的语法）之外，这不是与原始语法完全相同吗？这是否仍然不使用子查询？事实上，这不是与原始语法完全相同，只是使用方法语法而不是查询语法（或者不管另一个被调用了什么）？这是不是仍然没有使用子查询？事实上，除了使用方法语法而不是查询语法（或者不管另一个被调用了什么）之外，这不是和原来的完全一样吗？仍然错误。您只需检查

上下文中的元素是否超过10个。对于
查询中的每个元素，表中的元素是否超过10个。因此，您要么在
查询中获取所有元素，要么不获取任何元素。仍然错误。您只需检查
上下文中的元素是否超过10个。对于
查询中的每个元素，表中的元素是否超过10个。因此，您可以t对于
查询中的每个元素，检查
context.Table
中的元素是否超过10个。对于
查询中的每个元素，您只需检查
context.Table
中的元素是否超过10个。因此，您要么获取
查询中的所有元素，要么不获取任何元素。仍然错误。您只需检查
context.Table
中的元素是否超过10个在
query
中获取元素。因此，要么在
query
中获取所有元素，要么不获取任何元素。