.NET Why does IEnumerable.ToList() on an existing List create new array

Question

Just out of curiosity, why does calling IEnumerable.ToList() on an existing List not return the same instance? Same applies to IEnuerable.ToArray(). Would this not be better from a memory consumption standpoint?

I ran the following quick test:

  var things= new List<Thing>( new [] {new Thing(), new Thing()});
        Console.WriteLine(things.GetHashCode());

        things= things.ToList();
        Console.WriteLine(things.GetHashCode());

And I get different object instances. Why not simply the same instances?

Answer 1

This is intentionally done so to enable for the "copy list" scenario.

For example, it I do foreach( var a in list ) list.Remove(a), I will get an exception saying that "the collection has been modified" while the enumeration was in progress.

To fix this, I do: foreach( var a in list.ToList() ) list.Remove(a).

If you want the semantics along the lines of "convert to list if it is not one already", you'll have to handle it yourself. In fact, you could actually write a neat extension method for this:

public static IList<T> ToListIfNotAlready( this IEnumerable<T> source )
{
     var list = source as IList<T>;
     return list == null ? source.ToList() : list;
}

Yes, it could have been the other way around, but the LINQ designers chose this approach, and had every right to do so, as neither approach has distinct advantage in general case.

Answer 2

Because you can't modify the contents of an enumeration while it's being enumerated, there are times when you need to create a copy of the list so you can iterate over one copy and modify the other. ToList() is defined as returning a new list which is independent of the original list.