blocks|key|178049|text|您的.GroupBy(y+=>+y.LanguageCode).ToDictionaryAsync(y+=>+y.Key,+y+=>+y.Select(z+=>+z.Name));不能转换为SQL。EFCore3.0将抛出异常，以确保您知道Units中的所有记录都将在分组和映射到字典之前从数据库中提取。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|178050|这是EF核心3.0的最高突破变化。https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes|178051|entityMap|0|LINK|mutability|MUTABLE|url|https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes^0|2|2G|3C|5|0|H|2A|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@$9|V|A|W|1|X]]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Your <code>.GroupBy(y =&gt; y.LanguageCode).ToDictionaryAsync(y =&gt; y.Key, y =&gt; y.Select(z =&gt; z.Name));</code> cannot be converted to SQL.
EF Core 3.0 will throw exception to make sure you know that all records in <code>Units</code> will be fetched from database before grouping and map to Dictionary.

It's top breaking change in EF Core 3.0.
<a href="https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes" rel="noreferrer">https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes</a>

blocks|key|2197420|text|一个可能的解决方案(对我有用)是在一个GroupBy对象上创建List。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2197421|var+units+=+(
++await+context.Units
++.SelectMany(y+=>+y.UnitsI18N)
++.GroupBy(y+=>+y.LanguageCode)
++.ToDictionaryAsync(y+=>+y.Key,+y+=>+y.Select(z+=>+z.Name))
++).ToList().OrderBy(y+=>+y.Name);|code-block|syntax|javascript|2197422|entityMap^0|J|7|V|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

One possible solution (works for me) is to make the <code>GroupBy</code> on a <code>List</code> object.

<pre><code>var units = (
 await context.Units
 .SelectMany(y =&gt; y.UnitsI18N)
 .GroupBy(y =&gt; y.LanguageCode)
 .ToDictionaryAsync(y =&gt; y.Key, y =&gt; y.Select(z =&gt; z.Name))
 ).ToList().OrderBy(y =&gt; y.Name);
</code></pre>

blocks|key|1562947|text|linq+GroupBy方法可以执行数据库查询无法完成的任务。这就是linq抛出异常的原因。这不是缺少的特性，但是在linq的旧版本中，它只是枚举整个表，然后在本地运行GroupBy。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562948|Linq查询语法碰巧有一个group关键字，可以翻译成数据库查询。|offset|length|style|CODE|1562949|下面是一个使用查询语法在数据库上运行查询的主要工作示例：|1562950|var+kvPairs+=+from+y+in+context.Units
++++++++++++++from+u+in+y.UnitsI18N
++++++++++++++orderby+u.Name
++++++++++++++group+u+by+u.LanguageCode+into+g
++++++++++++++select+new+KeyValuePair<string,IEnumerable<string>>(g.Key,+g.Select(z+=>+z.Name));

return+new+Dictionary<string,IEnumerable<string>>>(kvPairs);|code-block|syntax|javascript|1562951|有关更多信息，请参见Microsoft的本文：https://learn.microsoft.com/en-us/ef/core/querying/complex-query-operators#groupby|1562952|entityMap|0|LINK|mutability|MUTABLE|url|https://learn.microsoft.com/en-us/ef/core/querying/complex-query-operators#groupby^0|0|D|5|0|0|0|N|2A|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

The linq GroupBy method can do things that a database query cannot. This is why linq is throwing the exception. It's not a missing feature, but in older versions of linq, it simply enumerated the entire table and then ran the GroupBy locally.

Linq query syntax happens to have a <code>group</code> keyword that can be translated to a database query. 

Here's a mostly working example of how to run your query on the database using query syntax:

<pre class="lang-cs prettyprint-override"><code>var kvPairs = from y in context.Units
 from u in y.UnitsI18N
 orderby u.Name
 group u by u.LanguageCode into g
 select new KeyValuePair&lt;string,IEnumerable&lt;string&gt;&gt;(g.Key, g.Select(z =&gt; z.Name));

return new Dictionary&lt;string,IEnumerable&lt;string&gt;&gt;&gt;(kvPairs);
</code></pre>

See this article from Microsoft for more information: <a href="https://learn.microsoft.com/en-us/ef/core/querying/complex-query-operators#groupby" rel="nofollow noreferrer">https://learn.microsoft.com/en-us/ef/core/querying/complex-query-operators#groupby</a>

blocks|key|2197473|text|对于LINQ+GroupBy做什么和SQL+GROUP+BY能够做什么，似乎有一种常见的误解。因为我掉进了同样的陷阱，最近不得不把我的头绕到这件事上，所以我决定对这个问题写一个更彻底的解释。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2197474|简短回答：|BOLD|2197475|LINQ+GroupBy是，与SQL+GROUP+BY语句有很大不同:+LINQ+just+根据键将底层集合划分为块，而SQL还应用聚合函数将每个块压缩为单个值。|2197476|这就是为什么EF必须在内存中执行LINQ类GroupBy的原因。|2197477|在EFCore3.0之前，这是隐式的，因此EF下载了所有结果行，然后应用了LINQ+GroupBy。但是，这种隐式行为可能使程序员期望整个LINQ查询在SQL中执行，当结果集相当大时，可能会对性能产生巨大影响。因此，GroupBy的隐式客户端评估是在EF+Core+3.0中完全禁用。|2197478|现在需要显式调用函数，如.AsEnumerable()或.ToList()，它们下载结果集并继续在内存中执行LINQ操作。|2197479|长答案：|2197480|下表solvedExercises将是这个答案的运行示例：|2197481|%2B-----------%2B------------%2B
%7C+StudentId+%7C+ExerciseId+%7C
%2B-----------%2B------------%2B
%7C+++++++++1+%7C++++++++++1+%7C
%7C+++++++++1+%7C++++++++++2+%7C
%7C+++++++++2+%7C++++++++++2+%7C
%7C+++++++++3+%7C++++++++++1+%7C
%7C+++++++++3+%7C++++++++++2+%7C
%7C+++++++++3+%7C++++++++++3+%7C
%2B-----------%2B------------%2B|code-block|syntax|javascript|2197482|本表中的记录X+%7C+Y表示学生X已经解决了练习Y。|2197483|在这个问题中，描述了LINQ的GroupBy方法的一个常见用例:获取一个集合并将其分组为块，其中每个块中的行共享一个公共键。|2197484|在我们的示例中，我们可能希望得到一个Dictionary<int,+List<int>>，它包含了每个学生解决的练习列表。对于LINQ，这是非常简单的：|2197485|var+result+=+solvedExercises
++++.GroupBy(e+=>+e.StudentId)
++++.ToDictionary(e+=>+e.Key,+e+=>+e.Select(e2+=>+e2.ExerciseId).ToList());|2197486|输出(完整代码请参见多管乐器)：|2197487|Student+#1:+1+2+
Student+#2:+2+
Student+#3:+1+2+3+|2197488|这很容易用C#数据类型来表示，因为我们可以尽可能深入地嵌套List和Dictionary。|2197489|现在，我们尝试将其想象为SQL查询结果。SQL查询结果通常表示为一个表，在该表中我们可以自由选择返回的列。要将上面的查询表示为SQL查询结果，我们需要|2197490|生成多个结果表，|unordered-list-item|2197491|将分组行放入数组或|2197492|以某种方式插入“结果集分隔符”。|2197493|据我所知，这些方法都没有在实践中得到实施。最多有一些类似MySQL的GROUP_CONCAT之类的讨厌的工作，它允许将结果行组合成一个字符串(相关的答案)。|2197494|因此，我们看到，SQL+不能产生与LINQ的GroupBy概念相匹配的结果。|2197495|相反，SQL只允许所谓的聚合:例如，如果我们想计算学生通过了多少练习，我们就会写。|2197496|SELECT+StudentId,COUNT(ExerciseId)
FROM+solvedExercises
GROUP+BY+StudentId|2197497|...which将产生|2197498|%2B-----------%2B-------------------%2B
%7C+StudentId+%7C+COUNT(ExerciseId)+%7C
%2B-----------%2B-------------------%2B
%7C+++++++++1+%7C+++++++++++++++++2+%7C
%7C+++++++++2+%7C+++++++++++++++++1+%7C
%7C+++++++++3+%7C+++++++++++++++++3+%7C
%2B-----------%2B-------------------%2B|2197499|聚合函数将一组行缩减为单个值，通常是标量。例如行计数、和、最大值、最小值和平均值。|2197500|这是由EF+Core实现的:执行|2197501|var+result+=+solvedExercises
++++.GroupBy(e+=>+e.StudentId)
++++.Select(e+=>+new+{+e.Key,+Count+=+e.Count()+})
++++.ToDictionary(e+=>+e.Key,+e+=>+e.Count);|2197502|生成上述SQL。注意Select，它告诉EF在生成的SQL查询中应该使用哪个聚合函数。|2197503|总之，LINQ函数比SQL+GroupBy语句更为通用，由于GROUP+BY的限制，该语句只允许返回一个单一的二维结果表。因此，在下载SQL结果集之后，必须在内存中计算类似问题中的查询和这个答案中的第一个示例的查询。|2197504|在EFCore3.0中，开发人员在这种情况下，选择抛出一个异常没有隐式地执行此操作，而是防止意外下载包含数百万行的整个、可能较大的表，这在开发过程中可能会因为一个小的测试数据库而被忽略。|2197505|entityMap|0|LINK|mutability|MUTABLE|url|https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes#linq-queries-are-no-longer-evaluated-on-the-client|1|https://dotnetfiddle.net/jMZz20|2|https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_group-concat|3|https://stackoverflow.com/a/18910206/8528014|4^0|7|7|M|8|0|0|5|0|5|7|J|8|D|1W|0|0|W|L|7|0|0|3Y|16|7|30|7|3G|H|0|0|0|1P|C|F|S|9|0|0|4|0|0|T|2|F|0|0|0|P|6|5|F|1|N|1|0|0|1Q|F|7|0|0|24|I|Q|0|0|0|G|A|4|1|0|0|0|19|T|4|Y|A|0|0|23|0|0|8|0|0|9|0|0|G|0|0|26|Y|C|Y|C|2|1Z|5|3|0|0|12|M|7|0|0|15|0|0|0|B|0|0|0|15|0|0|G|0|0|0|17|A|6|0|0|30|E|7|U|8|0|0|2L|G|F|4|0^^$0|@$1|2|3|4|5|6|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|2U|8|@$9|2V|A|2W|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]|$9|32|A|33|B|H]]|D|@]|E|$]]|$1|K|3|L|5|6|7|34|8|@$9|35|A|36|B|H]|$9|37|A|38|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|39|8|@$9|3A|A|3B|B|H]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|C]]|D|@$9|3G|A|3H|1|3I]]|E|$]]|$1|O|3|P|5|6|7|3J|8|@$9|3K|A|3L|B|H]|$9|3M|A|3N|B|C]|$9|3O|A|3P|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|3Q|8|@$9|3R|A|3S|B|H]]|D|@]|E|$]]|$1|S|3|T|5|6|7|3T|8|@$9|3U|A|3V|B|H]|$9|3W|A|3X|B|C]]|D|@]|E|$]]|$1|U|3|V|5|W|7|3Y|8|@]|D|@]|E|$X|Y]]|$1|Z|3|10|5|6|7|3Z|8|@$9|40|A|41|B|H]|$9|42|A|43|B|C]|$9|44|A|45|B|C]|$9|46|A|47|B|C]]|D|@]|E|$]]|$1|11|3|12|5|6|7|48|8|@$9|49|A|4A|B|H]|$9|4B|A|4C|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|4D|8|@$9|4E|A|4F|B|H]|$9|4G|A|4H|B|C]]|D|@]|E|$]]|$1|15|3|16|5|W|7|4I|8|@]|D|@]|E|$X|Y]]|$1|17|3|18|5|6|7|4J|8|@$9|4K|A|4L|B|H]]|D|@$9|4M|A|4N|1|4O]]|E|$]]|$1|19|3|1A|5|W|7|4P|8|@]|D|@]|E|$X|Y]]|$1|1B|3|1C|5|6|7|4Q|8|@$9|4R|A|4S|B|H]|$9|4T|A|4U|B|C]|$9|4V|A|4W|B|C]]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|4X|8|@$9|4Y|A|4Z|B|H]]|D|@]|E|$]]|$1|1F|3|1G|5|1H|7|50|8|@$9|51|A|52|B|H]]|D|@]|E|$]]|$1|1I|3|1J|5|1H|7|53|8|@$9|54|A|55|B|H]]|D|@]|E|$]]|$1|1K|3|1L|5|1H|7|56|8|@$9|57|A|58|B|H]]|D|@]|E|$]]|$1|1M|3|1N|5|6|7|59|8|@$9|5A|A|5B|B|H]|$9|5C|A|5D|B|C]]|D|@$9|5E|A|5F|1|5G]|$9|5H|A|5I|1|5J]]|E|$]]|$1|1O|3|1P|5|6|7|5K|8|@$9|5L|A|5M|B|H]|$9|5N|A|5O|B|C]]|D|@]|E|$]]|$1|1Q|3|1R|5|6|7|5P|8|@$9|5Q|A|5R|B|H]]|D|@]|E|$]]|$1|1S|3|1T|5|W|7|5S|8|@]|D|@]|E|$X|Y]]|$1|1U|3|1V|5|6|7|5T|8|@$9|5U|A|5V|B|H]]|D|@]|E|$]]|$1|1W|3|1X|5|W|7|5W|8|@]|D|@]|E|$X|Y]]|$1|1Y|3|1Z|5|6|7|5X|8|@$9|5Y|A|5Z|B|H]]|D|@]|E|$]]|$1|20|3|21|5|6|7|60|8|@$9|61|A|62|B|H]]|D|@]|E|$]]|$1|22|3|23|5|W|7|63|8|@]|D|@]|E|$X|Y]]|$1|24|3|25|5|6|7|64|8|@$9|65|A|66|B|H]|$9|67|A|68|B|C]]|D|@]|E|$]]|$1|26|3|27|5|6|7|69|8|@$9|6A|A|6B|B|H]|$9|6C|A|6D|B|C]|$9|6E|A|6F|B|C]]|D|@]|E|$]]|$1|28|3|29|5|6|7|6G|8|@$9|6H|A|6I|B|H]]|D|@$9|6J|A|6K|1|6L]]|E|$]]|$1|2A|3|-4|5|6|7|6M|8|@]|D|@]|E|$]]]|2B|$2C|$5|2D|2E|2F|E|$2G|2H]]|2I|$5|2D|2E|2F|E|$2G|2J]]|2K|$5|2D|2E|2F|E|$2G|2L]]|2M|$5|2D|2E|2F|E|$2G|2N]]|2O|$5|2D|2E|2F|E|$2G|2H]]]]

It seems like there is a common misconception about what LINQ <code>GroupBy</code> does and what SQL <code>GROUP BY</code> is able to do. Since I fell into the exact same trap and had to wrap my head around this recently, I decided to write a more thorough explanation of this issue.
<hr />
Short answer:
The LINQ <code>GroupBy</code> is much different from the SQL <code>GROUP BY</code> statement: LINQ just divides the underlying collection into chunks depending on a key, while SQL additionally applies an aggregation function to condense each of these chunks down into a single value.
This is why EF has to perform your LINQ-kind <code>GroupBy</code> in memory.
Before EF Core 3.0, this was done implicitly, so EF downloaded all result rows and then applied the LINQ <code>GroupBy</code>. However, this implicit behavior might let the programmer expect that the entire LINQ query is executed in SQL, with potentially enormous performance impact when the result set is rather large. For this reason, implicit client side evaluation of <code>GroupBy</code> was <a href="https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes#linq-queries-are-no-longer-evaluated-on-the-client" rel="nofollow noreferrer">disabled completely in EF Core 3.0</a>.
Now it is required to explicitly call functions like <code>.AsEnumerable()</code> or <code>.ToList()</code>, which download the result set and continue with in-memory LINQ operations.
<hr />
Long answer:
The following table <code>solvedExercises</code> will be the running example for this answer:
<pre><code>+-----------+------------+
| StudentId | ExerciseId |
+-----------+------------+
| 1 | 1 |
| 1 | 2 |
| 2 | 2 |
| 3 | 1 |
| 3 | 2 |
| 3 | 3 |
+-----------+------------+
</code></pre>
A record <code>X | Y</code> in this table denotes that student <code>X</code> has solved exercise <code>Y</code>.
In the question, a common use case of LINQ's <code>GroupBy</code> method is described: Take a collection and group it into chunks, where the rows in each chunk share a common key.
In our example, we might want to get a <code>Dictionary&lt;int, List&lt;int&gt;&gt;</code>, which contains a list of solved exercises for each student. With LINQ, this is very straightforward:
<pre><code>var result = solvedExercises
 .GroupBy(e =&gt; e.StudentId)
 .ToDictionary(e =&gt; e.Key, e =&gt; e.Select(e2 =&gt; e2.ExerciseId).ToList());
</code></pre>
Output (for full code see <a href="https://dotnetfiddle.net/jMZz20" rel="nofollow noreferrer">dotnetfiddle</a>):
<pre><code>Student #1: 1 2 
Student #2: 2 
Student #3: 1 2 3 
</code></pre>
This is easy to represent with C# datatypes, since we can nest <code>List</code> and <code>Dictionary</code> as deep as we like to.
Now we try to imagine this as an SQL query result. SQL query results are usually represented as a table, where we can freely choose the returned columns. To represent our above query as SQL query result, we would need to
<ul>
<li>generate multiple result tables,</li>
<li>put the grouped rows into an array or</li>
<li>somehow insert a &quot;result set separator&quot;.</li>
</ul>
As far as I know, none of these approaches is implemented in practice. At most, there are some hacky work-arounds like MySQL's <a href="https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_group-concat" rel="nofollow noreferrer"><code>GROUP_CONCAT</code></a>, which allows to combine the result rows into a string (<a href="https://stackoverflow.com/a/18910206/8528014">relevant SO answer</a>).
Thus we see, that SQL cannot yield results that match LINQ's notion of <code>GroupBy</code>.
Instead, SQL only allows so-called aggregation: If we, for example, wanted to count how many exercises have been passed by a student, we would write
<pre class="lang-sql prettyprint-override"><code>SELECT StudentId,COUNT(ExerciseId)
FROM solvedExercises
GROUP BY StudentId
</code></pre>
...which will yield
<pre><code>+-----------+-------------------+
| StudentId | COUNT(ExerciseId) |
+-----------+-------------------+
| 1 | 2 |
| 2 | 1 |
| 3 | 3 |
+-----------+-------------------+
</code></pre>
Aggregation functions reduce a set of rows into a single value, usually a scalar. Examples are row count, sum, maximum value, minimum value, and average.
This is implemented by EF Core: Executing
<pre><code>var result = solvedExercises
 .GroupBy(e =&gt; e.StudentId)
 .Select(e =&gt; new { e.Key, Count = e.Count() })
 .ToDictionary(e =&gt; e.Key, e =&gt; e.Count);
</code></pre>
generates the above SQL. Note the <code>Select</code>, which tells EF which aggregation function it should use for the generated SQL query.
<hr />
In summary, the LINQ <code>GroupBy</code> function is much more general than the SQL <code>GROUP BY</code> statement, which due to SQL's restrictions only allows to return a single, two dimensional result table. Thus, queries like the one in the question and the first example in this answer have to be evaluated in memory, after downloading the SQL result set.
Instead of implicitly doing this, in EF Core 3.0 the developers <a href="https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes#linq-queries-are-no-longer-evaluated-on-the-client" rel="nofollow noreferrer">chose to throw an exception in this case</a>; this prevents accidental downloading of an entire, potentially large table with millions of rows, which might get unnoticed during development due to a small test database.

blocks|key|2197558|text|var+test+=+unitOfWork.PostCategory.GetAll().Include(u=>u.category).GroupBy(g+=>+g.category.name).Select(s+=>+new
++++++++++++++++{

++++++++++++++++++++name+=+s.Key,
++++++++++++++++++++count+=+s.Count()

++++++++++++++++}).OrderBy(o=>o.count).ToList();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2197559|你可以试试这个代码部分..。会管用的..。我试过了|unstyled|2197560|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>var test = unitOfWork.PostCategory.GetAll().Include(u=&gt;u.category).GroupBy(g =&gt; g.category.name).Select(s =&gt; new
 {

 name = s.Key,
 count = s.Count()

 }).OrderBy(o=&gt;o.count).ToList();
</code></pre>
you can try this code part... it will works.. I have tried

blocks|key|178239|text|客户端组支持|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|178240|用EF+Core+3.1.15.0测试|178241|以下代码返回Client+side+GroupBy+is+not+supported.错误：|CODE|178242|MyEntity
++++.GroupBy(x+=>+x.MyProperty)
++++.ToDictionaryAsync(x+=>+x.Key,+x+=>+x.Count())
++++.Dump();|code-block|syntax|javascript|178243|但出于某种原因，您可以在.Select()之后添加一个.GroupBy()，它编译并运行预期的.GroupBy()：|178244|MyEntity
++++.GroupBy(x+=>+x.MyProperty)
++++.Select(g+=>+new+{+Key+=+g.Key,+Count+=+g.Count()+})
++++.ToDictionaryAsync(x+=>+x.Key,+x+=>+x.Count)
++++.Dump();|178245|汇编成：|178246|SELECT+[t].[MyProperty]+AS+[Key],+COUNT(*)+AS+[Count]
FROM+[dbo].[MyEntity]+AS+[t]
GROUP+BY+[t].[MyProperty]|178247|来源：https://stackoverflow.com/a/11564436/14565661|178248|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11564436/14565661^0|0|6|0|0|6|11|0|0|C|9|R|A|1B|A|0|0|0|0|3|19|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@$9|1C|A|1D|B|J]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1E|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1F|8|@$9|1G|A|1H|B|J]|$9|1I|A|1J|B|J]|$9|1K|A|1L|B|J]]|D|@]|E|$]]|$1|R|3|S|5|M|7|1M|8|@]|D|@]|E|$N|O]]|$1|T|3|U|5|6|7|1N|8|@]|D|@]|E|$]]|$1|V|3|W|5|M|7|1O|8|@]|D|@]|E|$N|O]]|$1|X|3|Y|5|6|7|1P|8|@]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|Z|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16]]]]

Client-Side Group-By is Supported
Tested with EF Core 3.1.15.0
The following code returns the <code>Client side GroupBy is not supported.</code> error:
<pre><code>MyEntity
 .GroupBy(x =&gt; x.MyProperty)
 .ToDictionaryAsync(x =&gt; x.Key, x =&gt; x.Count())
 .Dump();
</code></pre>
But for some reason, you can add a <code>.Select()</code> after the <code>.GroupBy()</code>, and it compiles and runs the expected SQL:
<pre><code>MyEntity
 .GroupBy(x =&gt; x.MyProperty)
 .Select(g =&gt; new { Key = g.Key, Count = g.Count() })
 .ToDictionaryAsync(x =&gt; x.Key, x =&gt; x.Count)
 .Dump();
</code></pre>
Compiles to:
<pre><code>SELECT [t].[MyProperty] AS [Key], COUNT(*) AS [Count]
FROM [dbo].[MyEntity] AS [t]
GROUP BY [t].[MyProperty]
</code></pre>
Source: <a href="https://stackoverflow.com/a/11564436/14565661">https://stackoverflow.com/a/11564436/14565661</a>

I have the following Entity Framework Core 3.0 query:

<pre><code>var units = await context.Units
 .SelectMany(y =&gt; y.UnitsI18N)
 .OrderBy(y =&gt; y.Name)
 .GroupBy(y =&gt; y.LanguageCode)
 .ToDictionaryAsync(y =&gt; y.Key, y =&gt; y.Select(z =&gt; z.Name));
</code></pre>

I get the following error:

<pre><code>Client side GroupBy is not supported.
</code></pre>

To run the query on the client, or part of it, I would do the following:

<pre><code>var units = context.Units
 .SelectMany(y =&gt; y.UnitsI18N)
 .OrderBy(y =&gt; y.Name)
 .AsEnumerable()
 .GroupBy(y =&gt; y.LanguageCode)
 .ToDictionary(y =&gt; y.Key, y =&gt; y.Select(z =&gt; z.Name));
</code></pre>

Now it works.

Why am I getting this error if I am not running the query on the client?

Client side GroupBy is not supported

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我有以下实体框架核心3.0查询：var units = await context.Units  .SelectMany(y => y.UnitsI18N)  .OrderBy(y => y.Name)  .GroupBy(y => y.LanguageCode)  .ToDictionaryAsync(y => y....

问不支持客户端GroupBy
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不支持客户端GroupByEN