c# - Linq-to-SQL 中的交叉连接效率如何？

Question

我知道，如果您使用 Linq-to-objects 执行交叉连接，则内部序列会针对外部序列的每个元素迭代一次。

下面的代码演示了ints2的多次迭代:

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication1
{
    internal class Program
    {
        private static void Main()
        {
            var ints1 = Ints1();
            var ints2 = Ints2();

            var test = from i in ints1
                       from j in ints2
                       select i*j;

            foreach (var i in test)
                Console.WriteLine(i);
        }

        private static IEnumerable<int> Ints1()
        {
            Console.WriteLine("Starting  Ints1()");

            for (int i = 0; i < 5; ++i)
                yield return i;

            Console.WriteLine("Ending Ints1()");
        }

        private static IEnumerable<int> Ints2()
        {
            Console.WriteLine("Starting Ints2()");

            for (int i = 0; i < 5; ++i)
                yield return i;

            Console.WriteLine("Ending Ints2()");
        }
    }
}

我的问题是:

如果您在 Linq-to-SQL 中执行相同类型的查询，它是否会优化为 SQL CROSS JOIN？或者它会多次评估内部序列(或做其他事情)？

(我几乎可以肯定它会被优化，但是在搜索网络后我没有找到关于这个的任何结论性文档。)

---

[编辑]

我只是想说明我问这个问题的原因。

Resharper 通常会在您迭代 IEnumerable 两次时警告您，但如果您使用嵌套的 from 到，它不会警告您执行交叉连接(例如我上面的示例代码)。

我想知道为什么它没有警告你，并认为这可能是由于以下两个原因之一:

这要么是疏忽，要么不需要，因为多重枚举对于嵌套 from 不是问题，因为它在 Linq-to-SQL 中变成了一种高效的操作。我认为这是后一个原因。

现在您可能想知道 Resharper 是否仍应发出警告，因为 Linq-to-objects 将 多次枚举内部序列 - 但我想这没有那么严重。

此外，我从未实际上在数据库上执行此类交叉联接(我也不打算这样做)，但我已经在 Linq-to-objects 中使用它们.

Answer 1

Linq-to-SQL 将 linq 查询转换为在数据库端 上运行的 T-SQL。

例如，如果你写:

from i in myContext.Table1
from j in myContext.Table2
select new {i,j}

Linq-to-SQL 会将其转换为类似于以下内容的 T-SQL 查询:

SELECT * 
FROM Table1, Table2

然后它将通过遍历结果集仅一次来提供生成的匿名类型对象。

希望这是有道理的。