这两段代码有什么区别？

Question

int[] div = new int[] {2,3,5};
IEnumerable<int> seq = new int[] {10,15,20,25,30};
int x;
for (int i=0; i<div.Length; i++){
  x = div[i];
  seq = seq.Where( s=> s%x ==0);
}
seq = seq.ToList();

AND

int[] div = new int[] {2,3,5};
IEnumerable<int> seq = new int[] {10,15,20,25,30};
for (int i=0; i<div.Length; i++){
  int y = div[i];
  seq = seq.Where( s=> s%y ==0);
}
seq = seq.ToList();

The first seq's final value is 10,15,20,25,30 and the second one's is 30. I'm a little confused about the difference between int x; and int y = div[i]; . Can someone explain this to me?
Thanks!

Answer 1

Invoking seq = seq.Where( s=> s%x ==0); does not iterate over elements. It only creates an IEnumarable encapsulating the iteration, that can be iterated in fututre.

So if you declare your x variable before the loop, the lambda, that you passed in Where() uses the same variable. Since you are changing its value in a loop, eventually only the last one will be actually used.

Instead of expression like:

seq.Where( s=> s % 2 == 0).Where( s=> s % 3 == 0).Where( s=> s % 5 == 0);

you get:

seq.Where( s=> s % 5 == 0).Where( s=> s % 5 == 0).Where( s=> s % 5 == 0);

Answer 2

The result is different because you are using lambda expression in the LINQ's Where() parameter. The actual execution of the all lambdas in Where() 's is performed on the very last row of both examples - the line where you perform .ToList() . Have a look at the Variable Scope in Lambda Expressions

The difference in the examples is how you initialize x/y .

In the first example there is only one memory slot for the variable x regardless of number of iterations of the foreach . The x always points to the same spot in the memory. Therefore there is only one value of the x on the last row and it is equal to the div[2] .

In the second example there is separate memory slot created for y in each iteration of the loop. As the program evaluates, the address where y points to is changed in every iteration of the foreach . You might imagine it as there are multiple y variables like y_1 , y_2 ,... Hence when evaluating the actual lambdas in Where() s the value of the y is different in every one of them.