关于LINQ的一个问题！疑点看红色字体这行！

Question

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace Linq1
{
    public class linq2
    {
        public string firstname { get; set; }
        public string lastname { get; set; }
        public string emailaddress { get; set; }
        public override string ToString()
        {
            return string.Format("{0} {1}\nemail: {2}", firstname, lastname, emailaddress);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<linq2> customers=createcustomerlist();
            IEnumerable<linq2> result = from customer in customers where customer.firstname == "donna" select customer;
            Console.WriteLine("firstname==\"donna\"");
                foreach(linq2 customer in result)
                {
                Console.WriteLine(customer.ToString());
                }
                customers[3].firstname = "donna";//为什么这里赋值后，result这个变量也改了呢！是不是又自动执行了上面Ienumerable<linq2>这行；                Console.WriteLine("firstname=\"donna\"(take two)");
           
                foreach (linq2 customer in result)
                {
                    Console.WriteLine(customer.ToString());
                }
        }
        private static List<linq2> createcustomerlist()
        {
        List<linq2> customer5=new List<linq2>
        {
        new linq2{firstname="orlando",lastname="gee",emailaddress="[email protected]"},
        new linq2{firstname="donna",lastname="carreras",emailaddress="[email protected]"}
        ,new linq2{firstname="bb166",lastname="qiu",emailaddress="[email protected]"}
        ,new linq2{firstname="jbqiu",lastname="qiujianbin",emailaddress="[email protected]"}
        ,new linq2{firstname="jbqiu168",lastname="qiujianbin168",emailaddress="[email protected]"}
        };
            return customer5;
        }
    }
}

Answer 1

 result是custom的集合，是引用，你改了  result里面了的内容，当然变量

Answer 2

这是linq查询表达式的一个特性：重复执行、延迟执行。
每一次遍历linq查询表达式的结果，都会重复执行一次，每个查询表达式只有在真正对其运算的时候才会执行。
延迟执行（使用的时候才会执行）：            List<int> numbers = new List<int>() { 1, 2 };
            IEnumerable<int> query = numbers.Select(i => i * 10);
            numbers.Add(3);
            //可见在linq查询表达式后才添加的“3”也在查询结果中
            foreach (var item in query)
            {
                Console.WriteLine(item);//输出：10，20，30
            }
重复执行（每一次调用查询表达式都会重复执行）：            List<int> numbers = new List<int>() { 1, 2 };
            IEnumerable<int> query = numbers.Select(i => i * 10);
            numbers.Add(3);
            //可见在linq查询表达式后才添加的“3”也在查询结果中
            foreach (var item in query)
            {
                Console.WriteLine(item);//输出：10，20，30
            }
            numbers.Clear();//清空numbers集合
            //可见linq查询表达式又重新执行了一次
            foreach (var item in query)
            {
                Console.WriteLine(item);//输出结果为空
            }

Answer 3

            List<int> numbers = new List<int>() { 1, 2 };
            IEnumerable<int> query = numbers.Select(i => i * 10).ToArray();
            numbers.Add(3);
            foreach (var item in query)
            {
                Console.WriteLine(item);//输出：10，20
            }            numbers.Clear();//清空numbers集合
            foreach (var item in query)
            {
                Console.WriteLine(item);//输出：10，20
            }
要避免linq查询表达式的这个特性可以在查询语句后调用一下方法语法的查询
查询表达式都有重复执行、延迟执行的特性，而方法语法就会立即执行。

Answer 4

延迟执行（使用的时候才会执行）
这是我看Linq资料里提及相当频繁的一点.

Answer 5

你将这句:
   IEnumerable<linq2> result = from customer in customers where customer.firstname == "donna" select customer;
修改成这样，就不会跟着变了：
   List<linq2> result = (from customer in customers where customer.firstname == "donna" select customer).ToList();这不就是LINQ的延迟查询特性么...

Answer 6

可Restul集合只存有赋值前Firstname为Donna的对象啊

Answer 7

我按F11运行到                customers[3].firstname = "donna"

Answer 8

为什么我按F11运行到                customers[3].firstname = "donna"这行时Restul值已改变

Answer 9

因为linq有重复执行的特性啊，你调试的时候去展开结果视图的时候，重新执行了linq查询表达式。

Answer 10

就是说每一次查询就会重新执行一次linq查询表达式。

Answer 11

customers 集合  result 是个对象 改了集合里的某个对象 。result当然变了！