Question

I came across an interesting question today where I have two methods that, at a quick glance, both do the same thing. That is return an IEnumerable of Foo objects.

I have defined them below as List1 and List2:

public class Foo
{
    public int ID { get; set; }
    public bool Enabled { get; set;}    
}

public static class Data
{
    public static IEnumerable<Foo> List1
    {
        get
        {
            return new List<Foo>
            {
                new Foo {ID = 1, Enabled = true},
                new Foo {ID = 2, Enabled = true},
                new Foo {ID = 3, Enabled = true}
            };
        }
    }

    public static IEnumerable<Foo> List2
    {
        get
        {
            yield return new Foo {ID = 1, Enabled = true};
            yield return new Foo {ID = 2, Enabled = true};
            yield return new Foo {ID = 3, Enabled = true};
        }
    }
}

Now consider the following tests:

IEnumerable<Foo> listOne = Data.List1;
listOne.Where(item => item.ID.Equals(2)).First().Enabled = false;
Assert.AreEqual(false, listOne.ElementAt(1).Enabled);
Assert.AreEqual(false, listOne.ToList()[1].Enabled);  

IEnumerable<Foo> listTwo = Data.List2;
listTwo.Where(item => item.ID.Equals(2)).First().Enabled = false;
Assert.AreEqual(false, listTwo.ElementAt(1).Enabled);
Assert.AreEqual(false, listTwo.ToList()[1].Enabled);  

These two methods seem to do the “same” thing.

Why do the second assertions in the test code fail?
Why is listTwo’s second “Foo” item not getting set to false when it is in listOne?

NOTE: I’m after an explanation of why this is allowed to happen and what the differences in the two are. Not how to fix the second assertion as I know that if I add a ToList call to List2 it will work.

Answer 1

The first block of code builds the items once and returns a list with the items.

The second block of code builds those items each time the IEnumerable is walked through.

This means that the second and third line of the first block operate on the same object instance. The second block’s second and third line operate on different instances of Foo (new instances are created as you iterate through).

The best way to see this would be to set breakpoints in the methods and run this code under the debugger. The first version will only hit the breakpoint once. The second version will hit it twice, once during the .Where() call, and once during the .ElementAt call. (edit: with the modified code, it will also hit the breakpoint a third time, during the ToList() call.)

The thing to remember here is that an iterator method (ie. it uses yield return) will be run every time the enumerator is iterated through, not just when the initial return value is constructed.