Changing a stuct inside another struct in a foreach loop

Question

The following code prints (when invoking MyMethod):

0
0
0
1

I would expect it to print:

0
0
1
1

Why is this?

Code:

private struct MyStruct
{
    public MyInnerStruct innerStruct;
}

private struct MyInnerStruct
{
    public int counter;

    public void AddOne()
    {
        ++counter;
    }
}

public static void MyMethod()
{
    MyStruct[] myStructs = new MyStruct[] { new MyStruct() };

    foreach (var myStruct in myStructs)
    {
        MyStruct myStructCopy = myStruct;

        Console.WriteLine(myStruct.innerStruct.counter);
        Console.WriteLine(myStructCopy.innerStruct.counter);

        myStruct.innerStruct.AddOne();
        myStructCopy.innerStruct.AddOne();

        Console.WriteLine(myStruct.innerStruct.counter);
        Console.WriteLine(myStructCopy.innerStruct.counter);
    }
}

Answer 1

I think you'll find that the MyStruct.innerStruct actually returns a copy of the struct, and not the struct itself. Therefore you're increasing the value of the copy...

Sure I read a blog about this recently somewhere.

If you change the following

myStruct.innerStruct.AddOne();
Console.WriteLine(myStruct.innerStruct.counter);

to

MyInnerStruct inner = myStruct.innerStruct;
inner.AddOne();
Console.WriteLine(inner.counter);

Then you should see it start working.

Answer 2

The reason you are seeing this behavior has to due with using an iteration variable. Iteration variables are read-only in the sense that in C# you cannot modify them (C# lang spec section 8.8.4 details this

The iteration variable corresponds to a read-only local variable with a scope that extends over the embedded statement

Playing with read-only mutable structs is a path to unexpected behavior. Instead of using the variable directly you are actually using a copy of the variable. Hence it's the copy that is getting incremented in the case of myStruct and not the actual value. This is why the original value remains unchanged.

Eric did a rather in depth article on this topic that you can access here

• http://blogs.msdn.com/ericlippert/archive/2008/05/14/mutating-readonly-structs.aspx

Yet another reason why you should always have immutable structs.