blocks|key|678132|text|因为在第二个示例中，您实际上将IEnumerable<T>转换为数组，而在第一个示例中，没有发生任何转换。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|678133|entityMap^0|F|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Because in the second example, you are actually converting the <code>IEnumerable&lt;T&gt;</code> to an array, whereas in the first example, no conversion is taking place.

blocks|key|894969|text|在方法2中，必须首先将整个数组转换为数组。此外，当First()的可读性如此之高时，混合数组访问似乎很笨拙。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|894970|entityMap^0|P|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

In method 2 the entire array must be converted to an array first. Also, it seems awkward to mix array access when <code>First()</code> is so much more readable.

blocks|key|895042|text|因为ToArray()将整个序列复制到一个数组中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|895043|方法2必须遍历整个序列来构建一个数组，然后返回第一个元素。|895044|方法1只是迭代足够的序列来找到第一个匹配的元素。|895045|entityMap^0|2|9|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

Because <code>ToArray()</code> copies the entire sequence to an array.

Method 2 has to iterate over the whole sequence to build an array, and then returns the first element.

Method 1 just iterates over enough of the sequence to find the first matching element.

blocks|key|678352|text|这是有道理的，ToArray可能会涉及一个拷贝，这总是会更昂贵，因为Linq不能保证你将如何使用你的数组，而First()只能在开始时返回单个元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|678353|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

This makes sense, ToArray probably involves a copy, which is always going to be more expensive, since Linq can't make any guarantees about how you're going to use your array, while First() can just return the single element at the beginning.

blocks|key|895160|text|ToArray()遍历了给定的整个序列，并从中创建和数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|895161|如果不调用ToArray()，First()会让Where()只返回第一个匹配的项，并立即返回。|895162|entityMap^0|0|9|0|5|9|F|7|O|7|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

<code>ToArray()</code> walks through the whole sequence it has been given and creates and array out of it.

If you don't callt <code>ToArray()</code>, <code>First()</code> lets <code>Where()</code> return just the first item that matches and immediatelly returns.

blocks|key|895226|text|First()是O(1)的复杂度|type|unstyled|depth|inlineStyleRanges|entityRanges|data|895227|ToArray()的复杂度为O(n)%2B1|895228|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

First() is complexity of O(1)

ToArray()[0] is complexity O(n)+1

blocks|key|895287|text|因为延迟执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|895288|代码ErrorCodes.Where(x+=>+ReturnedErrorCodes.Contains(x))不返回整数集合，而是返回一个能够返回整数流的表达式。它不会做任何实际的工作，直到你开始从它读取整数。|offset|length|style|CODE|895289|ToArray方法将消耗整个流，并将所有整数放入一个数组中。这意味着整个列表中的每一项都必须与错误代码进行比较。|895290|另一方面，First方法将只从流中获取第一项，然后停止从流中读取。这将使它更快，因为一旦找到匹配项，它就会停止将列表中的项与错误代码进行比较。|895291|entityMap^0|0|2|1H|0|0|7|0|5|5|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|M|$]]

Because of deferred execution.

The code <code>ErrorCodes.Where(x =&gt; ReturnedErrorCodes.Contains(x))</code> doesn't return a collection of integers, instead it returns an expression that is capable of returning a stream of integers. It doesn't do any actual work until you start reading integers from it.

The <code>ToArray</code> method will consume the entire stream and put all the integers in an array. This means that every item in the entire list has to be compared to the error codes.

The <code>First</code> method on the other hand will only get the first item from the stream, and then stop reading from the stream. This will make it a lot faster, because it will stop comparing items from the list to the error codes as soon as it finds a match.

blocks|key|678530|text|var+@e+=+array.GetEnumerator();

//+First
@e.MoveNext();
return+@e.Current;

//+ToArray+(with+yield+[0]+should+as+fast+as+First...)
while+(@e.MoveNext()+{
++++yield+return+@e.Current;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|678531|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var @e = array.GetEnumerator();

// First
@e.MoveNext();
return @e.Current;

// ToArray (with yield [0] should as fast as First...)
while (@e.MoveNext() {
 yield return @e.Current;
}
</code></pre>

I am running a test.

It looks like:

method 1) 

<pre><code>List&lt;int&gt; = new List&lt;int&gt;{1,2,4, .....} //assume 1000k
var result ErrorCodes.Where(x =&gt; ReturnedErrorCodes.Contains(x)).First();
</code></pre>

method 2) 

<pre><code>List&lt;int&gt; = new List&lt;int&gt;{1,2,4, .....} //assume 1000k
var result = ErrorCodes.Where(x =&gt; ReturnedErrorCodes.Contains(x)).ToArray()[0];
</code></pre>

Why is method 2 is so slow compared to method 1?

C# LINQ First() faster than ToArray()[0]?

我正在运行一个测试。看起来是这样的：方法1)List<int> = new List<int>{1,2,4, .....} //assume 1000kvar result ErrorCodes.Where(x => ReturnedErrorCodes.Contains(x)).First();方法2)List<i...

问C# LINQ First()比ToArray()快[0]？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C# LINQ First()比ToArray()快[0]？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C# LINQ First()比ToArray()快[0]？
EN