IEnumerable vs List - What to Use? How do they work?

后端 未结 10 2100
臣服心动
臣服心动 2020-11-22 03:57

I have some doubts over how Enumerators work, and LINQ. Consider these two simple selects:

List sel = (from animal in Animals 
                         


        
相关标签:
10条回答
  • 2020-11-22 04:09

    There are many cases (such as an infinite list or a very large list) where IEnumerable cannot be transformed to a List. The most obvious examples are all the prime numbers, all the users of facebook with their details, or all the items on ebay.

    The difference is that "List" objects are stored "right here and right now", whereas "IEnumerable" objects work "just one at a time". So if I am going through all the items on ebay, one at a time would be something even a small computer can handle, but ".ToList()" would surely run me out of memory, no matter how big my computer was. No computer can by itself contain and handle such a huge amount of data.

    [Edit] - Needless to say - it's not "either this or that". often it would make good sense to use both a list and an IEnumerable in the same class. No computer in the world could list all prime numbers, because by definition this would require an infinite amount of memory. But you could easily think of a class PrimeContainer which contains an IEnumerable<long> primes, which for obvious reasons also contains a SortedList<long> _primes. all the primes calculated so far. the next prime to be checked would only be run against the existing primes (up to the square root). That way you gain both - primes one at a time (IEnumerable) and a good list of "primes so far", which is a pretty good approximation of the entire (infinite) list.

    0 讨论(0)
  • 2020-11-22 04:14

    The advantage of IEnumerable is deferred execution (usually with databases). The query will not get executed until you actually loop through the data. It's a query waiting until it's needed (aka lazy loading).

    If you call ToList, the query will be executed, or "materialized" as I like to say.

    There are pros and cons to both. If you call ToList, you may remove some mystery as to when the query gets executed. If you stick to IEnumerable, you get the advantage that the program doesn't do any work until it's actually required.

    0 讨论(0)
  • 2020-11-22 04:15

    Nobody mentioned one crucial difference, ironically answered on a question closed as a duplicated of this.

    IEnumerable is read-only and List is not.

    See Practical difference between List and IEnumerable

    0 讨论(0)
  • 2020-11-22 04:16

    The most important thing to realize is that, using Linq, the query does not get evaluated immediately. It is only run as part of iterating through the resulting IEnumerable<T> in a foreach - that's what all the weird delegates are doing.

    So, the first example evaluates the query immediately by calling ToList and putting the query results in a list.
    The second example returns an IEnumerable<T> that contains all the information needed to run the query later on.

    In terms of performance, the answer is it depends. If you need the results to be evaluated at once (say, you're mutating the structures you're querying later on, or if you don't want the iteration over the IEnumerable<T> to take a long time) use a list. Else use an IEnumerable<T>. The default should be to use the on-demand evaluation in the second example, as that generally uses less memory, unless there is a specific reason to store the results in a list.

    0 讨论(0)
  • 2020-11-22 04:20

    A class that implement IEnumerable allows you to use the foreach syntax.

    Basically it has a method to get the next item in the collection. It doesn't need the whole collection to be in memory and doesn't know how many items are in it, foreach just keeps getting the next item until it runs out.

    This can be very useful in certain circumstances, for instance in a massive database table you don't want to copy the entire thing into memory before you start processing the rows.

    Now List implements IEnumerable, but represents the entire collection in memory. If you have an IEnumerable and you call .ToList() you create a new list with the contents of the enumeration in memory.

    Your linq expression returns an enumeration, and by default the expression executes when you iterate through using the foreach. An IEnumerable linq statement executes when you iterate the foreach, but you can force it to iterate sooner using .ToList().

    Here's what I mean:

    var things = 
        from item in BigDatabaseCall()
        where ....
        select item;
    
    // this will iterate through the entire linq statement:
    int count = things.Count();
    
    // this will stop after iterating the first one, but will execute the linq again
    bool hasAnyRecs = things.Any();
    
    // this will execute the linq statement *again*
    foreach( var thing in things ) ...
    
    // this will copy the results to a list in memory
    var list = things.ToList()
    
    // this won't iterate through again, the list knows how many items are in it
    int count2 = list.Count();
    
    // this won't execute the linq statement - we have it copied to the list
    foreach( var thing in list ) ...
    
    0 讨论(0)
  • 2020-11-22 04:25

    There is a very good article written by: Claudio Bernasconi's TechBlog here: When to use IEnumerable, ICollection, IList and List

    Here some basics points about scenarios and functions:

    enter image description here enter image description here

    0 讨论(0)
提交回复
热议问题