Question

I’m reading manning book about LINQ, and there is an example:

    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);
    }
}

with the following output:

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

Does this means, that ‘numbers’ is passed by reference? Does this behavior have to do something with lazy execution and yield? Or I’m on a wrong track here?

Answer 1

It’s to do with lazy execution. Every time you iterate through the query, that will be looking at numbers again. Indeed, if you change the value of a late element of numbers while you’re executing the query, you’ll see that change too. This is all changing the contents of the array.

Note that the query remembers the value of numbers at the time of the query creation – but that value is a reference, not the contents of the array. So if you change the value of numbers itself like this:

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

then that change won’t be reflected in the query.

Just to complicate things, if you use variables within other parts of the query, like this:

int x = 3;

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

then the variable x is captured rather than its value… so changing x will change the results of evaluating the query. That’s because the query expression is really translated to:

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

Note that here, x is used within a lambda expression, but numbers isn’t – that’s why they behave slightly differently.