ToList -- does it create a new list

Question

Let s say I have a class  public class MyObject      public int SimpleInt get set       And I have a List lt MyObject gt   and I ToList   it and then change one of the SimpleInt  will my change be propagated back to the original list  In other words  what would be the output of the following method   public void RunChangeList       var objs   new List lt MyObject gt    new MyObject   SimpleInt 0      var whatInt   ChangeToList objs      public int ChangeToList List lt MyObject gt  objects      var objectList   objects ToList      objectList 0  SimpleInt 5    return objects 0  SimpleInt       Why    P S  I m sorry if it seems obvious to find out  But I don t have compiler with me now

User · Answer

I don t see anywhere in the documentation that ToList   is always guaranteed to return a new list  If an IEnumerable is a List  it may be more efficient to check for this and simply return the same List    The worry is that sometimes you may want to be absolutely sure that the returned List is    to the original List  Because Microsoft doesn t document that ToList will return a new List  we can t be sure  unless someone found that documentation   It could also change in the future  even if it works now   new List IEnumerable enumerablestuff  is guaranteed to return a new List  I would use this instead

User · Answer

var objectList   objects ToList      objectList 0  SimpleInt 5    This will update the original object as well   The new list will contain references to the objects contained within it  just like the original list   You can change the elements either and the update will be reflected in the other     Now if you update a list  adding or deleting an item  that will not be reflected in the other list

User · Answer

I think that this is equivalent to asking if ToList does a deep or shallow copy  As ToList has no way to clone MyObject  it must do a shallow copy  so the created list contains the same references as the original one  so the code returns 5

User · Answer

In the case where the source object is a true IEnumerable  i e  not just a collection packaged an as enumerable   ToList   may NOT return the same object references as in the original IEnumerable  It will return a new List of objects  but those objects may not be the same or even Equal to the objects yielded by the IEnumerable when it is enumerated again

User · Answer

The accepted answer correctly addresses the OP s question based on his example  However  it only applies when ToList is applied to a concrete collection  it does not hold when the elements of the source sequence have yet to be instantiated  due to deferred execution   In case of the latter  you might get a new set of items each time you call ToList  or enumerate the sequence    Here is an adaptation of the OP s code to demonstrate this behaviour   public static void RunChangeList         var objs   Enumerable Range 0  10  Select     gt  new MyObject     SimpleInt   0         var whatInt   ChangeToList objs        whatInt gets 0    public static int ChangeToList IEnumerable lt MyObject gt  objects        var objectList   objects ToList        objectList First   SimpleInt   5      return objects First   SimpleInt      Whilst the above code may appear contrived  this behaviour can appear as a subtle bug in other scenarios  See my other example for a situation where it causes tasks to get spawned repeatedly

User · Answer

Just stumble upon this old post and thought of adding my two cents  Generally  if I am in doubt  I quickly use the GetHashCode   method on any object to check the identities  So for above -      public class MyObject       public int SimpleInt   get  set        class Program        public static void RunChangeList                 var objs   new List lt MyObject gt      new MyObject     SimpleInt   0              Console WriteLine  objs   0    objs GetHashCode             Console WriteLine  objs 0    0    objs 0  GetHashCode             var whatInt   ChangeToList objs           Console WriteLine  whatInt   0    whatInt GetHashCode                public static int ChangeToList List lt MyObject gt  objects                Console WriteLine  objects   0    objects GetHashCode             Console WriteLine  objects 0    0    objects 0  GetHashCode             var objectList   objects ToList            Console WriteLine  objectList   0    objectList GetHashCode             Console WriteLine  objectList 0    0    objectList 0  GetHashCode             objectList 0  SimpleInt   5          return objects 0  SimpleInt              private static void Main string   args                RunChangeList            Console ReadLine            And answer on my machine -   objs  45653674  objs 0   41149443 objects  45653674 objects 0   41149443 objectList  39785641 objectList 0   41149443 whatInt  5   So essentially the object that list carries remain the same in above code  Hope the approach helps

User · Answer

Yes  it creates a new list  This is by design    The list will contain the same results as the original enumerable sequence  but materialized into a persistent  in-memory  collection  This allows you to consume the results multiple times without incurring the cost of recomputing the sequence    The beauty of LINQ sequences is that they are composable  Often  the IEnumerable lt T gt  you get is the result of combining multiple filtering  ordering  and or projection operations  Extension methods like ToList   and ToArray   allow you to convert the computed sequence into a standard collection

User · Answer

ToList will always create a new list  which will not reflect any subsequent changes to the collection   However  it will reflect changes to the objects themselves  Unless they re mutable structs    In other words  if you replace an object in the original list with a different object  the ToList will still contain the first object  However  if you modify one of the objects in the original list  the ToList will still contain the same  modified  object

User · Answer

A new list is created but the items in it are references to the orginal items  just like in the original list   Changes to the list itself are independent  but to the items will find the change in both lists

User · Answer

From the Reflector d source   public static List lt TSource gt  ToList lt TSource gt  this IEnumerable lt TSource gt  source        if  source    null                throw Error ArgumentNull  source              return new List lt TSource gt  source       So yes  your original list won t be updated  i e  additions or removals  however the referenced objects will

User · Answer

ToList will create a brand new list   If the items in the list are value types  they will be directly updated  if they are reference types  any changes will be reflected back in the referenced objects

User · Answer

Yes  ToList will create a new list  but because in this case MyObject is a reference type then the new list will contain references to the same objects as the original list   Updating the SimpleInt property of an object referenced in the new list will also affect the equivalent object in the original list    If MyObject was declared as a struct rather than a class then the new list would contain copies of the elements in the original list  and updating a property of an element in the new list would not affect the equivalent element in the original list

[c#] ToList()-- does it create a new list?

Examples related to c#

Examples related to linq