LINQ 表达式中的值是否通过引用传递？

Question

我正在阅读有关 LINQ 的 manning 书籍，其中有一个示例：

    static class QueryReuse
    {
       static double Square(double n)
       {
         Console.WriteLine("Computing Square("+n+")...");
         return Math.Pow(n, 2);
       }
       public static void Main()
       {
         int[] numbers = {1, 2, 3};
         var query =
                  from n in numbers
                  select Square(n);

         foreach (var n in query)
              Console.WriteLine(n);

         for (int i = 0; i < numbers.Length; i++)
              numbers[i] = numbers[i]+10;

         Console.WriteLine("- Collection updated -");

         foreach (var n in query)
             Console.WriteLine(n);
    }
}

输出如下：

Computing Square(1)...
1
Computing Square(2)...
4
Computing Square(3)...
9
- Collection updated -
Computing Square(11)...
121
Computing Square(12)...
144
Computing Square(13)...
169

这是否意味着“数字”是通过引用传递的？这种行为是否与延迟执行和收益有关？或者我在这里走错了路？

Answer 1

这与惰性执行有关。每次迭代查询时，都会再次查看数字。事实上，如果您在执行查询时更改 numbers 的后期元素的值，，您也会看到该变化。这一切都改变了数组的内容。

请注意，查询会记住创建查询时的 numbers 值 - 但该值是一个引用，而不是数组的内容。因此，如果您像这样更改 numbers 本身的值：

numbers = new int[] { 10, 9, 8, 7 };

那么该更改将不会反映在查询中。

让事情变得复杂的是，如果您在查询的其他部分中使用变量，如下所示：

int x = 3;

var query = from n in numbers
            where n == x
            select Square(n);

那么将捕获 变量 x 而不是它的值...因此更改 x 将更改评估查询的结果。这是因为查询表达式实际上被转换为：

var query = numbers.Where(n => n == x)
                   .Select(n => Square(n));

请注意，这里，x 在 lambda 表达式中使用，但 numbers 不是 - 这就是为什么它们的行为略有不同。

Answer 2

对数字的引用通过值传递。但是，查询是延迟计算的，并且底层数组是可变的。

那么这意味着什么呢？

var arr = new[]{1,2,3,};
var q = arr.Select(i=>i*2);
Console.WriteLine(string.Join(", ",q.ToArray())); //prints 2, 4, 6
arr[0]=-1;
Console.WriteLine(string.Join(", ",q.ToArray())); //prints -2, 4, 6
// q refers to the original array, but that array has changed.
arr = new[]{2,3,4};
Console.WriteLine(string.Join(", ",q.ToArray())); //prints -2, 4, 6
//since q still refers to the original array, not the variable arr!

一般来说，如果您更改变量而不是其底层对象，它很快就会变得混乱，因此最好避免这样的更改。

例如：

var arr = new[]{1,2,};
var arr2 = new[]{1,2,};
var q = from a in arr
        from b in arr2
        select a*b;

// q is 1,2,2,4
arr = new[]{0,1}; //irrelevant, arr's reference was passed by value
// q is still 1,2,2,4

arr2 = new[]{0,1}; //unfortunately, relevant
// q is now 0, 1, 0, 2

要理解这一点，你需要了解编译过程的细节。查询表达式被定义为相当于大量使用闭包的扩展方法语法 (arr.Select...)。因此，实际上只有第一个可枚举或可查询的引用按值传递，其余的都在闭包中捕获，这意味着它们的引用实际上是按引用传递的。还困惑吗？ 避免更改这样的变量，以保持代码的可维护性和可读性。

Answer 3

查询完全按照原样存储 - 不是结果集，只是查询。

当您请求查询结果时，它会使用执行查询时的当前值（而不是创建查询时的值）来评估查询。如果您对同一查询进行两次评估，如果基础数据已更改，您可能会得到不同的结果，如问题中提供的示例所示。

Answer 4

这是因为对 numbers 的引用是一个闭包并与枚举的延迟执行相结合，给出了这个结果。

Answer 5

是的，numbers 变量是通过引用传递的，不是因为您使用 LINQ，而是因为数组是引用类型。

输出变化的事实是由于 LINQ 的延迟/延迟计算造成的。