linq related question

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Comparer.csd
{
    class Program
    {
        /* Confusion is regarding how ToList() method works. Does it do the deep copy or shallow copy??

        /**********OUTPUT
         a a b
         a b c
         a c a
        -----------------
         a a b
         a c a
        -----------------
        1
        2
        3
        OUTPUT ENDS************/

        static void Main(string[] args)
        {
            List<test> list = new List<test>();
            list.Add(new test("a", "b", "c"));
            list.Add(new test("a", "c", "a"));
            list.Add(new test("a", "a", "b"));

            /// sort the list based on first name and last name

            IEnumerable<test> soretedCollection = from t in list
                                     orderby t._fname ascending, t._mname ascending
                                     select t;
            Print(soretedCollection);
            /// remove the first object from the list
            list.RemoveAt(0);
            /// print the list .
            /// Removal of the item from the list is reflected here so I guess sorted collection and list both 
            /// are re开发者_StackOverflowfering the same data structure
            /// what if I will do 
            /// list = soretedCollection.ToList<test>(); /// is it going to change the reference of the list if some other object 
            /// is holding the reference??
            Print(soretedCollection);

            Dictionary<int, int> dic = new Dictionary<int, int>();            
            dic.Add(1, 1);
            dic.Add(2, 1);
            dic.Add(3, 1);
            List<int> keys = dic.Keys.ToList<int>();
            /// remove the dictionary entry with key=2
            dic.Remove(2);
            /// how come this time it did not remove the second item becuase it is removed from the dictionary.
            for (int i = 0; i < keys.Count; ++i)
            {
                Console.WriteLine(keys[i].ToString());
            }

            Console.Read();
        }

        static void Print(IEnumerable<test> list)
        {
            foreach (test t in list)
            {
                t.Print();
            }
            Console.WriteLine("---------------------");
        }
    }

}

Calling .ToList() forces eager execution of the full enumeration - the result of this is a separate list from the original enumeration, so any changes after .ToList() won't be reflected in that list. The actual items in this list are the same (same object references) as in the original enumeration as @Johannes Rudolph pointed out - so yes that's a shallow copy.

The IEnumerable<test> though will be lazily executed over the source collection - only when you actively enumerate the items (i.e. by using foreach or .ToList()) will the enumeration create an Enumerator that takes the source collection as it is at that point in time - that means if there are changes in the underlying collection before the Enumerator is created these will be reflected in the enumeration.

ToList will always create a shallow copy of your list, that is the returned list will reference the same objects as your source IEnumerable does, but the List returned is a copy of the source.

See MSDN.