LinQ to SQL 在使用 Any() 时抛出 Stackoverflow 异常

Question

我正在使用如下所示的 LinQ 查询

public List<TEntity> GetEntities<TEntity>(int[] ids)
{
    var someDbSet = new DbSet<TEntity>();

    var resultQ = someDbSet.Where(t => !ids.Any() || ids.Contains(t.ID)); //<= crashing line

    return resultQ.toList();
}

它通常有效，但在某些情况下，当 id 大小约为 7000 个项目时，它会崩溃。抛出的异常信息为"Exception of type 'System.WhosebugException' was thrown."。它没有堆栈跟踪或 InnerException。

我也得到了这个信息："EntityFramework.pdb not loaded... contains the debug information required to find the source for the module EntityFramework.dll"

这是一个已知错误吗？或者有人可以解释为什么当数组更大时它不起作用吗？

我正在使用 .NET Framework 4.5、EntityFramework 6.1.3、EntityFramework6.Npgsql 3.0.3

Answer 1

根据您的错误信息，执行堆栈溢出时抛出的异常是因为它包含太多的嵌套方法调用。作为 MSDN

数组的默认最大大小为 2 GB。

在 64 位环境中，您可以通过在运行-time 环境中将 gcAllowVeryLargeObjects 配置元素的 enabled 属性设置为 true 来避免大小限制。

此外，您的 ID 超过了 2 GB 的限制。我认为这可能是原因

Answer 2

你能这样试试吗？

    public List<TEntity> GetEntities<TEntity>(int[] ids)
    {
        var someDbSet = new DbSet<TEntity>();
        var resultQ = new List<your_list_type>();
        foreach( var id in ids) {
          resultQ.Add(someDbSet.Where(prm => prm.ID == id).FirstOrDefault());
}
        return resultQ;

    }

Answer 3

如果我们将只有两个值 int[] ids = {1, 2} 的数组传递给您的方法 GetEntities EntityFramework 将生成下一个查询：

SELECT 
[Extent1].[Id] AS [Id], 
...
FROM [dbo].[Entity] AS [Extent1]
WHERE ( NOT EXISTS (SELECT 
    1 AS [C1]
    FROM  (SELECT 
        1 AS [C0]
        FROM  ( SELECT 1 AS X ) AS [SingleRowTable1]
    UNION ALL
        SELECT 
        1 AS [C0]
        FROM  ( SELECT 1 AS X ) AS [SingleRowTable2]) AS [UnionAll1]
)) OR (1 = [Extent1].[Id]) OR (2 = [Extent1].[Id])

如果我们增加 ids 数组中的元素数量，则此查询将变得更加复杂，嵌套层级也会增加。我认为 EntityFramework 使用一些递归算法为 !ids.Any() 表达式生成 SQL 代码。当 ids 数组中的元素数量增加时，递归的深度也会增加。因此，当 ids 数组中的元素数量（以及递归的深度）很大时，它会生成 WhosebugException。

如果我们删除 !ids.Any() 表达式，将生成下一个查询：

SELECT 
[Extent1].[Id] AS [Id], 
...
FROM [dbo].[Entity] AS [Extent1]
WHERE [Extent1].[Id] IN (1,2)

当 ids 数组中的元素数量很大时，此类查询不会生成 WhosebugException。因此，最好从 LINQ 查询中提取 !ids.Any() 表达式：

public List<TEntity> GetEntities<TEntity>(int[] ids)
{
    var someDbSet = new DbSet<TEntity>();

    if (!ids.Any())
        return someDbSet.ToList();

    var resultQ = someDbSet.Where(t => ids.Contains(t.ID));
    return resultQ.toList();
}

您还应该考虑到 WHERE IN 条件下的项目数量限制：Limit on the WHERE col IN (...) condition.

ionutnespus 写道：

Yes, extracting the condition outside Where() is working. Still, I couldn't find any explanation why EF would use such a complicated algorithm for such a simple condition. Any thoughts on that?

我决定通过扩展这个 post 来回答这个问题，因为 asnwer 很大并且包含代码。

我不确定为什么 EF 会生成如此复杂的查询，但我进行了一些研究，这是我的想法。如果我们修改您的 GetEntites 方法并在 LINQ 查询中使用下一个条件：

someDbSet.Where(t => !ids.Any(i => i == 3) || ids.Contains(t.ID));

如果 ids = {1, 2}:

将生成下一个 SQL-查询

SELECT 
[Extent1].[Id] AS [Id], 
...
FROM [dbo].[Entity] AS [Extent1]
WHERE ( NOT EXISTS (
    SELECT 1 AS [C1]
    FROM (
        SELECT 1 AS [C0] FROM  ( SELECT 1 AS X ) AS [SingleRowTable1] WHERE 3 = 1
        UNION ALL
        SELECT 1 AS [C0] FROM  ( SELECT 1 AS X ) AS [SingleRowTable2] WHERE 3 = 2
        ) AS [UnionAll1]
)) OR (1 = [Extent1].[Id]) OR (2 = [Extent1].[Id])

在这里您可以看到 NOT EXISTS 条件包含两个子查询，每个子查询检查 ids 数组的下一个元素是否等于所需值。我认为用NOT EXISTS SQL-条件来表示Any()方法是符合逻辑的。但是为什么 EF 会为每个数组元素生成一个子查询呢？在我看来，EF 这样做是因为 EF 团队试图编写生成不依赖于数据库类型的查询的算法。但这只是我的意见。在 github.

上问 EF 团队可能会更好

LinQ to SQL 在使用 Any() 时抛出 Stackoverflow 异常

LinQ to SQL throws Stackoverflow exception when using Any()

c#

linq

postgresql

linq-to-sql

entity-framework-6