by Miguel de Icaza

This is a trivial change to implement, and would turn what today is an error into useful behavior.

Consider the following C# program:

struct Rect { public int X, Y, Width, Height; } class Window { Rect bounds; public Rect Bounds { get { return bounds; } set { // Some code that needs to run when the property is set WindowManager.Invalidate (bounds); WindowManager.Invalidate (value); bounds = value; } } }

Currently, code like this:

Window w = new Window (); w.Bounds.X = 10;

Produces the error:

Cannot modify the return value of "Window.Bounds.X" because it is not a variable

The reason is that the compiler returns a copy of the "bounds" structure and making changes to the returned value has no effect on the original property.

If we had used a public field for Bounds, instead of a property, the above code would compile, as the compiler knows how to get to the "Bounds.X" field and set its value.

My suggestion is to alter the C# compiler to turn what today is considered an error when accessing properties and doing what the developer expects.

The compiler would rewrite the above code into:

Window w = new Window (); var tmp = w.Bounds; tmp.X = 10; w.Bounds = tmp;

Additionally, it should cluster all of the changes done in a single call, so:

Window w = new Window (); w.Bounds.X = 10; w.Bounds.Y = 20;

Will be compiled as:

Window w = new Window (); var tmp = w.Bounds; tmp.X = 10; tmp.Y = 20; w.Bounds = tmp;

To avoid calling the setter for each property set in the underlying structure.

The change is trivial and wont break any existing code.