linq相关问题

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 refering 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("---------------------");
        }
    }

}

Answer 1

调用.ToList()强制急切执行完整枚举 - 结果是与原始枚举的单独列表，因此.ToList()之后的任何更改都不会反映在该清单中。这个列表中的实际项目与原始枚举中的相同（相同的对象引用）正如@Johannes Rudolph所指出的那样 - 所以是的，这是一个浅层副本。

IEnumerable<test>虽然会在源集合上执行懒惰，但只有当您主动枚举项目时（例如，使用foreach或.ToList()）才会枚举创建一个Enumerator，它在该时间点获取源集合 - 这意味着如果在创建Enumerator之前底层集合中有更改，这些将在枚举中反映出来。

Answer 2

ToList将始终创建列表的浅表副本，即返回的列表将引用与源IEnumerable相同的相同的对象，但返回的列表是一份来源的副本。

请参阅MSDN。