blocks|key|944479|text|ToList()会创建一个新的列表，并将元素放入其中，这意味着执行ToList()会产生相关的成本。在小集合的情况下，它的成本不会非常明显，但在使用ToList的情况下，拥有大量的集合可能会导致性能损失。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|944480|通常，您不应该使用ToList()，除非您所做的工作不能不将集合转换为列表。例如，如果您只想遍历集合，则不需要执行ToList|944481|如果您正在对数据源(例如使用LINQ+to+SQL的数据库)执行查询，则执行ToList的成本要高得多，因为当您将ToList与LINQ+to+SQL配合使用时，而不是执行延迟执行，即在需要时加载项(这在许多情况下可能是有益的)，它会立即将项从数据库加载到内存中|944482|entityMap^0|0|8|X|8|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

<code>ToList()</code> creates a new List and put the elements in it which means that there is an associated cost with doing <code>ToList()</code>. In case of small collection it won't be very noticeable cost but having a huge collection can cause a performance hit in case of using ToList.

Generally you should not use ToList() unless work you are doing cannot be done without converting collection to List. For example if you just want to iterate through the collection you don't need to perform ToList

If you are performing queries against a data source for example a Database using LINQ to SQL then the cost of doing ToList is much more because when you use ToList with LINQ to SQL instead of doing Delayed Execution i.e. load items when needed (which can be beneficial in many scenarios) it instantly loads items from Database into memory

blocks|key|2366341|text|考虑到检索文件列表的性能，ToList()可以忽略不计。但对于其他场景则并非如此。这真的取决于你在哪里使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2366342|2366343|在调用数组、列表或其他集合时，您会创建该集合的副本作为List<T>。这里的性能取决于列表的大小。你应该在真正必要的时候这样做。|unordered-list-item|2366344|2366345|在您的示例中，您将在数组上调用它。它遍历数组并将项逐个添加到新创建的列表中。因此，性能影响取决于文件数量。|2366346|2366347|在调用IEnumerable<T>时，您将实例化IEnumerable<T>+(通常是查询)。|2366348|2366349|entityMap^0|D|8|0|0|R|7|0|0|0|0|3|E|O|E|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|N|3|O|5|I|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$]]

Considering the performance of retrieving file list, <code>ToList()</code> is negligible. But not really for other scenarios. That really depends on where you are using it.
<ul>
<li>When calling on an array, list, or other collection, you create a copy of the collection as a <code>List&lt;T&gt;</code>. The performance here depends on the size of the list. You should do it when really necessary.
In your example, you call it on an array. It iterates over the array and adds the items one by one to a newly created list. So the performance impact depends on the number of files.
</li>
<li>When calling on an <code>IEnumerable&lt;T&gt;</code>, you materialize the <code>IEnumerable&lt;T&gt;</code> (usually a query).
</li>
</ul>

blocks|key|243461|text|ToList将创建一个新的列表，并将元素从原始源复制到新创建的列表中，因此唯一要做的就是从原始源复制元素，并依赖于源的大小|type|unstyled|depth|inlineStyleRanges|entityRanges|data|243462|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|$]]

ToList Will create a new list and copy elements from original source to the newly created list so only thing is to copy the elements from the original source and depends on the source size

blocks|key|5719101|text|它将和做以下事情一样有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5719102|var+list+=+new+List<T>(items);|code-block|syntax|javascript|5719103|如果您反汇编接受IEnumerable<T>的构造函数的源代码，您将看到它将执行以下操作：|offset|length|style|CODE|5719104|5719105|调用collection.Count，所以如果collection是一个IEnumerable<T>，它将强制执行。如果collection是一个数组、列表等，它应该是O(1).|unordered-list-item|5719106|If+collection+implements+ICollection<T>，它将使用ICollection<T>.CopyTo方法将这些项保存在内部数组中。它应该是O(n)，因为collection.|5719107|If+collection的长度不实现ICollection<T>，它将迭代集合的项，并将它们添加到内部列表中。|5719108|5719109|所以，是的，它将消耗更多的内存，因为它必须创建一个新的列表，并且在最坏的情况下，它将是+O(n)，，因为它将迭代通过collection来创建每个元素的副本。|BOLD|5719110|entityMap^0|0|0|8|E|0|0|2|G|N|A|10|E|1O|A|2C|4|0|3|A|P|E|18|L|2C|4|0|3|A|J|E|0|0|18|4|18|4|1M|A|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|16|8|@$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|P|7|1H|8|@$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]]|9|@]|A|$]]|$1|S|3|T|5|P|7|1Q|8|@$I|1R|J|1S|K|L]|$I|1T|J|1U|K|L]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1W|8|@$I|1X|J|1Y|K|X]|$I|1Z|J|20|K|L]|$I|21|J|22|K|L]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|23|8|@]|9|@]|A|$]]]|Z|$]]

It will be as (in)efficient as doing:

<pre><code>var list = new List&lt;T&gt;(items);
</code></pre>

If you disassemble the source code of the constructor that takes an <code>IEnumerable&lt;T&gt;</code>, you will see it will do a few things:

<ul>
<li>Call <code>collection.Count</code>, so if <code>collection</code> is an <code>IEnumerable&lt;T&gt;</code>, it will force the execution. If <code>collection</code> is an array, list, etc. it should be <code>O(1)</code>.</li>
<li>If <code>collection</code> implements <code>ICollection&lt;T&gt;</code>, it will save the items in an internal array using the <code>ICollection&lt;T&gt;.CopyTo</code> method. It should be <code>O(n)</code>, being <code>n</code> the length of the collection.</li>
<li>If <code>collection</code> does not implement <code>ICollection&lt;T&gt;</code>, it will iterate through the items of the collection, and will add them to an internal list.</li>
</ul>

So, yes, it will consume more memory, since it has to create a new list, and in the worst case, it will be <code>O(n)</code>, since it will iterate through the <code>collection</code> to make a copy of each element.

blocks|key|5719146|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5719147|在调用toList()时是否会对性能产生影响？|blockquote|5719148|5719149|5719150|当然可以。从理论上讲，即使是i%2B%2B也会对性能产生影响，它可能会使程序减慢几个刻度。|offset|length|style|CODE|5719151|+.ToList+做了什么？|BOLD|5719152|当您调用.ToList时，代码调用Enumerable.ToList()，这是return+new+List<TSource>(source)的一个扩展方法。在相应的构造函数中，在最坏的情况下，它会遍历项容器，并将它们逐个添加到新的容器中。因此，它的行为对性能影响很小。成为应用程序的性能瓶颈是不可能的。|5719153|问题中的代码有什么问题|5719154|Directory.GetFiles遍历文件夹并将所有文件的名称立即返回到内存中，但它有一个潜在的风险，即string[]消耗大量内存，从而减慢一切。|5719155|应该做什么，然后|5719156|那得看情况。如果您(以及您的业务逻辑)保证文件夹中的文件量始终很小，则代码是可以接受的。但还是建议使用惰性版本:+C#4中的Directory.EnumerateFiles。这更像是一个查询，它不会立即执行，你可以在上面添加更多的查询，如下所示：|5719157|Directory.EnumerateFiles(myPath).Any(s+=>+s.Contains("myfile"))|code-block|syntax|javascript|5719158|一旦找到名称包含"myfile“的文件，它将立即停止搜索路径。这显然比.GetFiles有更好的性能。|5719159|entityMap^0|0|0|0|0|E|3|0|1|7|9|5|1|7|0|4|7|H|J|13|W|0|0|2|0|0|I|0|0|8|0|1Q|O|0|0|Z|9|0^^$0|@$1|2|3|-4|4|5|6|17|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|18|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1B|7|@$H|1C|I|1D|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|1E|7|@$H|1F|I|1G|J|N]|$H|1H|I|1I|J|N]|$H|1J|I|1K|J|K]]|8|@]|9|$]]|$1|O|3|P|4|5|6|1L|7|@$H|1M|I|1N|J|K]|$H|1O|I|1P|J|K]|$H|1Q|I|1R|J|K]]|8|@]|9|$]]|$1|Q|3|R|4|5|6|1S|7|@$H|1T|I|1U|J|N]]|8|@]|9|$]]|$1|S|3|T|4|5|6|1V|7|@$H|1W|I|1X|J|K]]|8|@]|9|$]]|$1|U|3|V|4|5|6|1Y|7|@$H|1Z|I|20|J|N]]|8|@]|9|$]]|$1|W|3|X|4|5|6|21|7|@$H|22|I|23|J|K]]|8|@]|9|$]]|$1|Y|3|Z|4|10|6|24|7|@]|8|@]|9|$11|12]]|$1|13|3|14|4|5|6|25|7|@$H|26|I|27|J|K]]|8|@]|9|$]]|$1|15|3|-4|4|5|6|28|7|@]|8|@]|9|$]]]|16|$]]

<blockquote>
 Is there a performance impact when calling toList()?
</blockquote>

Yes of course. Theoretically even <code>i++</code> has a performance impact, it slows the program for maybe a few ticks.

What does <code>.ToList</code> do?

When you invoke <code>.ToList</code>, the code calls <code>Enumerable.ToList()</code> which is an extension method that <code>return new List&lt;TSource&gt;(source)</code>. In the corresponding constructor, under the worst circumstance, it goes through the item container and add them one by one into a new container. So its behavior affects little on performance. It's impossible to be a performance bottle neck of your application.

What's wrong with the code in the question

<code>Directory.GetFiles</code> goes through the folder and returns all files' names immediately into memory, it has a potential risk that the string[] costs a lot of memory, slowing down everything.

What should be done then

It depends. If you(as well as your business logic) gurantees that the file amount in the folder is always small, the code is acceptable. But it's still suggested to use a lazy version: <code>Directory.EnumerateFiles</code> in C#4. This is much more like a query, which will not be executed immediately, you can add more query on it like: 

<pre><code>Directory.EnumerateFiles(myPath).Any(s =&gt; s.Contains("myfile"))
</code></pre>

which will stop searching the path as soon as a file whose name contains "myfile" is found. This is obviously has a better performance then <code>.GetFiles</code>.

blocks|key|944573|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944574|“是否存在需要考虑的性能影响？”|blockquote|944575|944576|944577|您的精确方案的问题是，首先也是最重要的是，您真正关心的性能将来自硬盘驱动器的速度和驱动器缓存的效率。|944578|从这个角度来看，影响肯定是可以忽略的，以至于不需要考虑NO+it。|offset|length|style|BOLD|944579|但是只有当你真的需要List<>结构的特性来使你更有效率，或者你的算法更友好，或者其他一些优点的时候。否则，您只是故意添加一个无关紧要的性能影响，而没有任何原因。在这种情况下，您自然不应该这样做！:)|CODE|944580|entityMap^0|0|0|0|0|0|R|2|0|A|6|0^^$0|@$1|2|3|-4|4|5|6|S|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|T|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|U|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|V|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|W|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|X|7|@$J|Y|K|Z|L|M]]|8|@]|9|$]]|$1|N|3|O|4|5|6|10|7|@$J|11|K|12|L|P]]|8|@]|9|$]]|$1|Q|3|-4|4|5|6|13|7|@]|8|@]|9|$]]]|R|$]]

<blockquote>
 "is there a performance impact that needs to be considered?"
</blockquote>

The issue with your precise scenario is that first and foremost your real concern about performance would be from the hard-drive speed and efficiency of the drive's cache. 

From that perspective, the impact is surely negligible to the point that NO it need not be considered.

BUT ONLY if you really need the features of the <code>List&lt;&gt;</code> structure to possibly either make you more productive, or your algorithm more friendly, or some other advantage. Otherwise, you're just purposely adding an insignificant performance hit, for no reason at all. In which case, naturally, you shouldn’t do it! :)

blocks|key|947992|text|IEnumerable.ToList()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|947993|是的，IEnumerable.ToList()确实有性能影响，它是O(n)操作，尽管它可能只需要在性能关键型操作中注意。|947994|ToList()操作将使用List(IEnumerable+collection)构造函数。此构造函数必须复制数组(更一般地说是IEnumerable<T>)，否则将来对原始数组的修改也会在源T[]上发生变化，这通常是不可取的。|947995|我想重申，这只会对一个巨大的列表产生影响，复制内存块是一个执行起来相当快的操作。|947996|小贴士，As+vs+To|947997|您会注意到，在LINQ中有几个以As+(如AsEnumerable())和To+(如ToList())开头的方法。以To开头的方法需要类似于上面的转换(即，可能会影响性能)，而以As开头的方法不需要也将只需要一些强制转换或简单的操作。|947998|有关List<T>的其他详细信息|947999|如果您感兴趣，这里有更多关于List<T>工作原理的详细信息:)|948000|List<T>还使用称为动态数组的结构，该结构需要按需调整大小，此resize事件将旧数组的内容复制到新数组中。所以它从small和increases+in+size+if+required开始。|948001|这就是List上Capacity和Count属性之间的区别。Capacity是指幕后数组的大小，Count是List<T>中的项数，始终为<=+Capacity。因此，当向列表中添加一项时，将其增加到超过Capacity时，List<T>的大小会加倍，并复制该数组。|948002|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb342261.aspx|1|http://msdn.microsoft.com/en-us/library/fkbw11z0.aspx|2|http://msdn.microsoft.com/en-us/library/bb335435.aspx|3|4|https://stackoverflow.com/a/15446006/1156119|5|http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx|6|http://msdn.microsoft.com/en-us/library/y52x03h2.aspx|7|http://msdn.microsoft.com/en-us/library/27b47ht3.aspx^0|0|K|0|3|K|3|K|0|0|0|8|D|S|1S|E|2O|3|D|S|1|0|0|4|2|A|2|0|G|2|L|E|11|2|16|8|1M|2|2H|2|L|E|2|16|8|3|0|2|7|0|E|7|0|0|7|1U|T|4|0|3|4|8|8|H|5|U|8|1C|5|1I|7|1X|B|2U|8|34|7|3|4|5|8|8|6|H|5|7|0^^$0|@$1|2|3|4|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@$9|1O|A|1P|1|1Q]]|E|$]]|$1|H|3|I|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@$9|20|A|21|1|22]]|E|$]]|$1|J|3|K|5|6|7|23|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|24|8|@$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|29|8|@$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]|$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]|$9|2I|A|2J|B|C]|$9|2K|A|2L|B|C]]|D|@$9|2M|A|2N|1|2O]|$9|2P|A|2Q|1|2R]]|E|$]]|$1|P|3|Q|5|6|7|2S|8|@$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|2V|8|@$9|2W|A|2X|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|2Y|8|@$9|2Z|A|30|B|C]]|D|@$9|31|A|32|1|33]]|E|$]]|$1|V|3|W|5|6|7|34|8|@$9|35|A|36|B|C]|$9|37|A|38|B|C]|$9|39|A|3A|B|C]|$9|3B|A|3C|B|C]|$9|3D|A|3E|B|C]|$9|3F|A|3G|B|C]|$9|3H|A|3I|B|C]|$9|3J|A|3K|B|C]|$9|3L|A|3M|B|C]]|D|@$9|3N|A|3O|1|3P]|$9|3Q|A|3R|1|3S]|$9|3T|A|3U|1|3V]]|E|$]]|$1|X|3|-4|5|6|7|3W|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]|15|$5|10|11|12|E|$13|16]]|17|$5|10|11|12|E|$13|18]]|19|$5|10|11|12|E|$13|14]]|1A|$5|10|11|12|E|$13|1B]]|1C|$5|10|11|12|E|$13|1D]]|1E|$5|10|11|12|E|$13|1F]]|1G|$5|10|11|12|E|$13|1H]]]]

<h2><code>IEnumerable.ToList()</code></h2>

Yes, <a href="http://msdn.microsoft.com/en-us/library/bb342261.aspx" rel="noreferrer"><code>IEnumerable&lt;T&gt;.ToList()</code></a> does have a performance impact, it is an O(n) operation though it will likely only require attention in performance critical operations.

The <code>ToList()</code> operation will use the <a href="http://msdn.microsoft.com/en-us/library/fkbw11z0.aspx" rel="noreferrer"><code>List(IEnumerable&lt;T&gt; collection)</code></a> constructor. This constructor must make a copy of the array (more generally <code>IEnumerable&lt;T&gt;</code>), otherwise future modifications of the original array will change on the source <code>T[]</code> also which wouldn't be desirable generally. 

I would like to reiterate this will only make a difference with a huge list, copying chunks of memory is quite a fast operation to perform.

<h2>Handy tip, <code>As</code> vs <code>To</code></h2>

You'll notice in LINQ there are several methods that start with <code>As</code> (such as <a href="http://msdn.microsoft.com/en-us/library/bb335435.aspx" rel="noreferrer"><code>AsEnumerable()</code></a>) and <code>To</code> (such as <a href="http://msdn.microsoft.com/en-us/library/bb342261.aspx" rel="noreferrer"><code>ToList()</code></a>). The methods that start with <code>To</code> require a conversion like above (ie. may impact performance), and the methods that start with <code>As</code> do not and will just require some cast or simple operation.

<h2>Additional details on <code>List&lt;T&gt;</code></h2>

Here is a little more detail on how <code>List&lt;T&gt;</code> works in case you're interested :)

A <code>List&lt;T&gt;</code> also uses a construct called a dynamic array which needs to be resized on demand, this resize event copies the contents of an old array to the new array. So it starts off small and <a href="https://stackoverflow.com/a/15446006/1156119">increases in size if required</a>.

This is the difference between the <a href="http://msdn.microsoft.com/en-us/library/y52x03h2.aspx" rel="noreferrer"><code>Capacity</code></a> and <a href="http://msdn.microsoft.com/en-us/library/27b47ht3.aspx" rel="noreferrer"><code>Count</code></a> attributes on <a href="http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx" rel="noreferrer"><code>List&lt;T&gt;</code></a>. <code>Capacity</code> refers to the size of the array behind the scenes, <code>Count</code> is the number of items in the <code>List&lt;T&gt;</code> which is always <code>&lt;= Capacity</code>. So when an item is added to the list, increasing it past <code>Capacity</code>, the size of the <code>List&lt;T&gt;</code> is doubled and the array is copied.

blocks|key|944641|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944642|在调用toList()时是否会对性能产生影响？|blockquote|944643|944644|944645|是的有。使用扩展方法，Enumerable.ToList()将从IEnumerable<T>源代码集合构造一个新的List<T>对象，这当然会对性能产生影响。|offset|length|style|CODE|944646|但是，了解List<T>可能会帮助您确定性能影响是否显著。|944647|List<T>使用数组(T[])来存储列表的元素。数组一旦分配就无法扩展，因此List<T>将使用超大的数组来存储列表中的元素。当List<T>增长到超过底层数组的大小时，必须分配一个新的数组，并且必须将旧数组的内容复制到新的更大的数组中，然后列表才能增长。|944648|当从IEnumerable<T>构建新的List<T>时，有两种情况：|944649|944650|源集合实现ICollection<T>：然后使用ICollection<T>.Count获取源集合的确切大小，并在使用ICollection<T>.CopyTo()将源集合的所有元素复制到支持数组之前分配一个匹配的支持数组。此操作非常有效，并且可能会映射到用于复制内存块的某些CPU指令。然而，就性能而言，新数组需要内存，复制所有elements.|ordered-list-item|944651|Otherwise需要CPU周期，源集合的大小是未知的，IEnumerable<T>的枚举器用于将每个源元素一次一个添加到新的List<T>。最初，支持数组是空的，并且创建了一个大小为4的数组。然后，当这个数组太小时，大小加倍，所以后备数组像这样增长4，8，16，32等等。每次后备数组增长时，它必须重新分配，并且到目前为止存储的所有元素都必须被复制。与第一种情况相比，这种操作的成本要高得多，在第一种情况下，可以立即创建正确大小的数组。|944652|944653|此外，如果您的源集合包含33个元素，则列表将最终使用64个元素组成的数组，这会浪费一些内存。|944654|在您的示例中，源集合是一个实现ICollection<T>的数组，因此，除非源数组非常大，否则性能影响不是您应该关心的问题。调用ToList()将简单地复制源数组并将其包装在List<T>对象中。即使是第二种情况的性能对于小型集合来说也不是什么值得担心的问题。|944655|entityMap^0|0|0|0|0|B|J|W|E|1L|7|0|5|7|0|0|7|C|3|13|7|1T|7|0|2|E|K|7|0|0|5|E|O|K|1N|N|0|S|E|1R|7|0|0|0|F|E|1S|8|2F|7|0^^$0|@$1|2|3|-4|4|5|6|14|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|15|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|16|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|17|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|18|7|@$H|19|I|1A|J|K]|$H|1B|I|1C|J|K]|$H|1D|I|1E|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|1F|7|@$H|1G|I|1H|J|K]]|8|@]|9|$]]|$1|N|3|O|4|5|6|1I|7|@$H|1J|I|1K|J|K]|$H|1L|I|1M|J|K]|$H|1N|I|1O|J|K]|$H|1P|I|1Q|J|K]]|8|@]|9|$]]|$1|P|3|Q|4|5|6|1R|7|@$H|1S|I|1T|J|K]|$H|1U|I|1V|J|K]]|8|@]|9|$]]|$1|R|3|-4|4|5|6|1W|7|@]|8|@]|9|$]]|$1|S|3|T|4|U|6|1X|7|@$H|1Y|I|1Z|J|K]|$H|20|I|21|J|K]|$H|22|I|23|J|K]]|8|@]|9|$]]|$1|V|3|W|4|U|6|24|7|@$H|25|I|26|J|K]|$H|27|I|28|J|K]]|8|@]|9|$]]|$1|X|3|-4|4|5|6|29|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|5|6|2A|7|@]|8|@]|9|$]]|$1|10|3|11|4|5|6|2B|7|@$H|2C|I|2D|J|K]|$H|2E|I|2F|J|K]|$H|2G|I|2H|J|K]]|8|@]|9|$]]|$1|12|3|-4|4|5|6|2I|7|@]|8|@]|9|$]]]|13|$]]

<blockquote>
 Is there a performance impact when calling toList()?
</blockquote>

Yes there is. Using the extension method <code>Enumerable.ToList()</code> will construct a new <code>List&lt;T&gt;</code> object from the <code>IEnumerable&lt;T&gt;</code> source collection which of course has a performance impact.

However, understanding <code>List&lt;T&gt;</code> may help you determine if the performance impact is significant.

<code>List&lt;T&gt;</code> uses an array (<code>T[]</code>) to store the elements of the list. Arrays cannot be extended once they are allocated so <code>List&lt;T&gt;</code> will use an over-sized array to store the elements of the list. When the <code>List&lt;T&gt;</code> grows beyond the size the underlying array a new array has to be allocated and the contents of the old array has to be copied to the new larger array before the list can grow.

When a new <code>List&lt;T&gt;</code> is constructed from an <code>IEnumerable&lt;T&gt;</code> there are two cases:

<ol>
<li>The source collection implements <code>ICollection&lt;T&gt;</code>: Then <code>ICollection&lt;T&gt;.Count</code> is used to get the exact size of the source collection and a matching backing array is allocated before all elements of the source collection is copied to the backing array using <code>ICollection&lt;T&gt;.CopyTo()</code>. This operation is quite efficient and probably will map to some CPU instruction for copying blocks of memory. However, in terms of performance memory is required for the new array and CPU cycles are required for copying all the elements.</li>
<li>Otherwise the size of the source collection is unknown and the enumerator of <code>IEnumerable&lt;T&gt;</code> is used to add each source element one at a time to the new <code>List&lt;T&gt;</code>. Initially the backing array is empty and an array of size 4 is created. Then when this array is too small the size is doubled so the backing array grows like this 4, 8, 16, 32 etc. Every time the backing array grows it has to be reallocated and all elements stored so far have to be copied. This operation is much more costly compared to the first case where an array of the correct size can be created right away.

Also, if your source collection contains say 33 elements the list will end up using an array of 64 elements wasting some memory.</li>
</ol>

In your case the source collection is an array which implements <code>ICollection&lt;T&gt;</code> so the performance impact is not something you should be concerned about unless your source array is very large. Calling <code>ToList()</code> will simply copy the source array and wrap it in a <code>List&lt;T&gt;</code> object. Even the performance of the second case is not something to worry about for small collections.

When using <code>ToList()</code>, is there a performance impact that needs to be considered?

I was writing a query to retrieve files from a directory, which is the query:

<code>string[] imageArray = Directory.GetFiles(directory);</code>

However, since I like to work with <code>List&lt;&gt;</code> instead, I decided to put in...

<code>List&lt;string&gt; imageList = Directory.GetFiles(directory).ToList();</code>

So, is there some sort of performance impact that should be considered when deciding to do a conversion like this - or only to be considered when dealing with a large number of files? Is this a negligible conversion?

Is there a performance impact when calling ToList()?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

使用ToList()时，是否需要考虑性能影响？我正在编写一个从目录中检索文件的查询，该查询如下：string[] imageArray = Directory.GetFiles(directory);但是，由于我更喜欢使用List<>，所以我决定将...List<string> imageList = Director...

问在调用ToList()时是否会影响性能？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在调用ToList()时是否会影响性能？EN