[Proposal] Allow in-place modification of the members of the struct-typed read & writable Property

[Delsin-Yu]

In current version of C#, the following example causes the CS1612 compiler error:

using System.Numerics;

var instance = new MyClass();
instance.Position.Y += 1; // CS1612
Console.WriteLine(instance.Position);

class MyClass
{
    public Vector3 Position
    {
        get;
        set
        {
            field = value;
            NotifyUpdate();
        }
    }

    private void NotifyUpdate() { /* Implementation Detail */ }
}

I'm proposing a syntactic sugar that allows the above usecase.
The following code:

instance.Position.Y += 1;

will be translated to

Vector3 temp = instance.Position;
temp.Y += 1;
instance.Position = temp;

[TahirAhmadov]

This can lead to unexpected results in multi-threaded scenarios, and while it's perfectly fine for you to do this - because you know multiple threads aren't in play in your case - adding it to the language may be too risky - it would become a feature which sometimes does something very bad.

[colejohnson66]

Swap int for any T that is over 8 bytes and overloads + (like Vector3). Same problem. And what do you mean “atomic”? With integers, the race is still not safe - sure reads and writes are atomic, but there’s still a separate read/write.

Again: this isn’t Rust - shared mutability exists. And the language allowing some forms but not others is, IMO, wrong. Especially when the “illegal” form could be rewritten into “legal” code that works the exact same way it would be lowered to if allowed.

[timcassell]

I think the proposed syntax is bad, as it's hiding what is actually happening and leads to performance pitfalls if multiple mutations are done, but I think it would be useful to allow full object mutation with a new syntax, akin to = { syntax in object initializers. What that syntax should be, I'm not sure. Something like instance.Position = { X++, Y++ }; doesn't look quite right. Maybe combine with with keyword? instance.Position = with { X++, Y++ }; Still kinda ugly, but I don't have any good ideas.

[Delsin-Yu]

instance.Position = instance.Position with { X ++, Y += 1 }; sounds more familiar, but if this went down the road then someone would eventually ask how to introduce instance.Position =instance.Position with { Y = SomeMethod(value_of_y*) };

[Delsin-Yu]

and leads to performance pitfalls if multiple mutations are done

I think a new Analyzer rule can easily detect such usage and emit compile time warning & quick fixes.

[HaloFour]

The team aren't likely to change the language to accommodate what they would immediately warn is bad practice with an analyzer.