static void TestDeferredExecution()
        {
            var numbers = new List<int>();
            numbers.Add(1);
            IEnumerable<int> query = numbers.Select(n => n * 10);   // Build query

            numbers.Add(2);                 // Add an extra element after the query
            foreach (int n in query)
                Console.Write(n + "|");     // 10|20|
        }

可以看出，我们在查询创建之后添加的number也包含在查询结果中了，这是因为直到foreach语句对query进行遍历时，LINQ查询才会执行，这时，数据源numbers已经包含了我们后来添加的元素2，LINQ的这种特性就是延迟执行。除了下面两种查询运算符，所有其他的运算符都是延迟执行的：

            int matches = numbers.Where(n => (n % 2) == 0).Count();     // 1

        static void TestReevaluation()
        {
            var numbers = new List<int>() { 1, 2 };

            IEnumerable<int> query = numbers.Select(n => n * 10);   // Build query
            foreach (int n in query) Console.Write(n + "|");        // 10|20|

            numbers.Clear();
            foreach (int n in query) Console.Write(n + "|");        // <nothing>
        }

有时候，重复执行对我们说可不是一个优点，理由如下：

        static void TestDefeatReevaluation()
        {
            var numbers = new List<int>() { 1, 2 };

            List<int> timesTen = numbers
                .Select(n => n * 10)
                .ToList();   // Executes immediately into a List<int>

            numbers.Clear();
            Console.Write(timesTen.Count);  // Still 2
        }

变量捕获

        static void TestCapturedVariable()
        {
            int[] numbers = { 1, 2 };

            int factor = 10;
            IEnumerable<int> query = numbers.Select(n => n * factor);
            factor = 20;
            foreach (int n in query)
                Console.Write(n + "|");     // 20|40|
        }

这个特性在我们通过foreach循环创建查询时会变成一个真正的陷阱。假如我们想要去掉一个字符串里的所有元音字母，我们可能会写出如下的query：

              IEnumerable<char> query = "How are you, friend.";

            query = query.Where(c => c != 'a');
            query = query.Where(c => c != 'e');
            query = query.Where(c => c != 'i');
            query = query.Where(c => c != 'o');
            query = query.Where(c => c != 'u');

            foreach (char c in query) Console.Write(c); //Hw r y, frnd.

尽管程序结果正确，但我们都能看出，如此写出来的程序不够优雅。所以我们会自然而然的想到使用foreach循环来重构上面这段程序：

            IEnumerable<char> query = "How are you, friend.";

            foreach(char vowel in "aeiou")
                query = query.Where(c => c != vowel);

            foreach (char c in query) Console.Write(c); //How are yo, friend.

结果中只有字母u被过滤了，咋一看，有没有吃一惊呢！但只要仔细一想就能知道原因：因为vowel定义在循环之外，所以每个lambda表达式都捕获了同一变量。当我们的query执行时，vowel的值是什么呢？不正是被过滤的字母u嘛。要解决这个问题，我们只需把循环变量赋值给一个内部变量即可，如下面的temp变量作用域只是当前的lambda表达式。

            IEnumerable<char> query = "How are you, friend.";

            foreach (char vowel in "aeiou")
            {
                char temp = vowel;
                query = query.Where(c => c != temp);
            }　　　　　

　　　　　　　　foreach (char i in "aeiou")
　　　　　　　　{ 
　　　　　　　　　　query=query.Where(n => n != i).ToArray();//这样也是可以的
　　　　　　　　}

            foreach (char c in query) Console.Write(c); //Hw r y, frnd.

延迟执行的实现原理

        IEnumerable<int> lessThanTen = new int[] { 5, 12, 3 }.Where(n => n < 10);

            IEnumerable<int> query = new int[] { 5, 12, 3 }
                .Where(n => n < 10)
                .OrderBy(n => n)
                .Select(n => n * 10);