Question

我正在使用以下查询

foreach (var callDetailsForNode_ReArrange in callDetailsForNodes_ReArrange)
{
    var test = from r1 in dtRowForNode.AsEnumerable()
               join r2 in dtFileRowForNode.AsEnumerable()
               on r1.Field<int>("Lng_Upload_Id") equals r2.Field<int>("Lng_Upload_Id")
               where ((r1.Field<string>("Txt_Called_Number") == callDetailsForNode_ReArrange.caller2.ToString()) || r1.Field<string>("Txt_Calling_Number") == callDetailsForNode_ReArrange.caller2.ToString())
               select r2.Field<string>("Txt_File_Name");

    var d = test.Distinct();
}

此处此查询立即运行。但是当我添加

时

string[] str =d.ToArray();
strFileName = string.Join(",", str);

运行大约需要4-5秒。是什么让它在添加.ToArray()时变得如此缓慢？

Answer 1

此时此查询立即运行。

到目前为止，除了构建表示待处理查询的延迟执行模型之外，它实际上并没有完成任何事情。在你的情况下通过MoveNext()在迭代器上调用foreach，即通过.ToArray()，它不会开始迭代。

所以：需要时间，因为正在做工作。

考虑：

static IEnumerable<int> GetData()
{
    Console.WriteLine("a");
    yield return 0;
    Console.WriteLine("b");
    yield return 1;
    Console.WriteLine("c");
    yield return 2;
    Console.WriteLine("d");
}
static void Main()
{
    Console.WriteLine("start");
    var data = GetData();
    Console.WriteLine("got data");
    foreach (var item in data)
        Console.WriteLine(item);
    Console.WriteLine("end");
}

输出：

start
got data
a
0
b
1
c
2
d
end

请注意，这项工作并非一次全部发生 - 它都是延迟的（a来自got data之后）和假脱机（我们没有得到a，... d，0，... 2）。

相关：这大致是Distinct()的工作原理，来自评论：

public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source) {
    var seen = new HashSet<T>();
    foreach(var item in source) {
        if(seen.Add(item)) yield return item;
    }
}

...

和新的Join操作：

public static string Join(this IEnumerable<string> source, string separator) {
    using(var iter = source.GetEnumerator()) {
        if(!iter.MoveNext()) return "";
        var sb = new StringBuilder(iter.Current);
        while(iter.MoveNext())
            sb.Append(separator).Append(iter.Current);
        return sb.ToString();
    }
}

并使用：

string s = d.Join(",");

Answer 2

因为查询没有任何关系，直到你迭代它，.ToArray()。

需要注意的一点是，当查询开始迭代时，连接的右侧（在您的示例中，r2 in dtFileRowForNode.AsEnumerable()）将完全枚举，即使只是第一个元素结果被访问 - 但直到那时。

所以，如果你这样做了：

d.First()

r2 in dtFileRowForNode.AsEnumerable()序列将被完全迭代（并在内存中缓冲），但只会评估r1 in dtRowForNode.AsEnumerable()的第一个元素。

由于这个原因，如果连接中的一个序列比另一个序列大得多，那么将大序列放在连接的左侧会更有效（以内存方式）。连接右侧的整个序列将缓冲在内存中。

（我应该指出，只适用于Linq-to-objects.Linq-to-SQL将在数据库中运行这些查询，因此它处理缓冲。）

Answer 3

您需要阅读linq语句的默认评估。查询未完成，除非您明确要求结果 - 例如在foreach中进行迭代，调用ToArray，ToList，Sum，First或其他方法之一评估查询。

因此，您的查询需要花费很长时间才能完成，而不是ToArray调用。

.ToArray（）的慢LINQ查询

3 个答案: