CS1612 (Cannot modify the return value...) generated for indexer set accessor call

Question

Why does C# compiler generate error CS1612 for code that attempts to call indexer set accessor on immutable property?

using System;
using System.Collections.Generic;
using System.Text;

namespace StructIndexerSetter
{
    struct IndexerImpl {
        private TestClass parent;

        public IndexerImpl(TestClass parent)
        {
            this.parent = parent;
        }

        public int this[int index]
        {
            get {
                return parent.GetValue(index);
            }
            set {
                parent.SetValue(index, value);
            }
        }
    }

    class TestClass
    {
        public IndexerImpl Item
        {
            get
            {
                return new IndexerImpl(this);
            }
        }

        internal int GetValue(int index)
        {
            Console.WriteLine("GetValue({0})", index);
            return index;
        }
        internal void SetValue(int index, int value)
        {
            Console.WriteLine("SetValue({0}, {1})", index, value);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var testObj = new TestClass();
            var v = testObj.Item[0];

            // this workaround works as intended, ultimately calling "SetValue" on the testObj
            var indexer = testObj.Item;
            indexer[0] = 1;

            // this produced the compiler error
            // error CS1612: Cannot modify the return value of 'StructIndexerSetter.TestClass.Item' because it is not a variable
            // note that this would not modify the value of the returned IndexerImpl instance, but call custom indexer set accessor instead
            testObj.Item[0] = 1;
        }
    }
}

According to the documentation, this error means the following: "An attempt was made to modify a value type that is produced as the result of an intermediate expression but is not stored in a variable. This error can occur when you attempt to directly modify a struct in a generic collection, as shown in the following example:"

The error should not be produced in this case, since the actual value of the expression is not being modified. Note: Mono C# compiler handles the case as expected, successfully compiling the code.

Answer 1

The C# compiler doesn't bother trying to understand what your code is actually doing in most cases. In this case, you're right that it will all work out, but this is some rather unusual code. As you may know, the following line:

var indexer = testObj.Item;

Results in the creation of a completely separate instance of IndexerImpl, since that's the way structs work. So normally when you change something inside it, with a line like indexer[0] = 1; you are changing indexer, not testObj.Item. Since testObj.Item[0] = 1; does the same thing, just without the named variable, your change is immediately discarded (or would be, if the value were stored inside the struct and not in the TestClass).

I'd say that not only are mutable structs evil, so are your pseudo-mutable structs here, and they should probably not be used in the real world. If you're looking for a real-world solution, try moving public int this[int index] inside TestClass, and access like testObj[0] = 1;.

Update given what you say in the comment on this answer, you should switch IndexerImpl to be a class (reference type), and write your properties in a way that you don't create lots of objects unnecessarily, e.g.

    private IndexerImpl _item;
    public IndexerImpl Item
    {
        get
        {
            return _item ?? (_item = new IndexerImpl(this));
        }
    }

This will reuse the instance, and will have practically no overhead.