I was wondering how well properties were integrated into C#.  For example, C# lets you use += with the properties.   It's easy enough to convert:
    MyProperty += 4
to
    MyProperty = MyProperty + 4

However, C# won't let you pass a property in as a ref parameter.  For example:
    void PassIntByRef(ref int x)
    ...
    PassIntByRef(ref MyProperty);
  <-- this is illegal in C#.

At first I thought C# was being lame. Afterall, why couldn't it do something like:
    int __temp = MyProperty;
    PassIntByRef(ref __temp); 
    MyProperty = __temp;
 

Then it hit me that was not correct behavior. Consider this example:
 

    int a = 5;
    PassPairByRef(ref a, ref a);
    ...

    void PassPairByRef(ref int x1, ref int x2) {
        x1++;         // 1) caller's reference to x1 (variable a) is immediately changed
        // since x1 and x2 are the same ref, x2 is changed too!
        // 2) So both x1 and x2 are now updated to 6
    }


The naive codegen proposal above obviously would break down here. PassPairByRef  would need some pretty fancy codegen to handle a reference- property. The only way I can imagine is that it would effectively need a pair of delegates to the get_MyProperty  and set_MyProperty methods. That would codegen to something like:       

    delegate int Getter();
    delegate void Setter(int val);
    void PassPairByRef(Getter x1_get, Setter x1_set, Getter x2_get, Setter x2_set)
    {
        x1_set(x1_get() + 1);
    }
          
      
And then the callsite would look something like (this is pseudo-code):
    PassPairByRef(
            new Getter(get_MyProperty), new Setter(set_MyProperty), // ref for x1
            new Getter(get_MyProperty), new Setter(set_MyProperty)); // ref for x2

Since this is obviously less efficient than passing normal (non-property) values by-ref, the codegen would probably want two separate versions of the method: one for the normal case and one for properties.

Some random closing thoughts:
1. A higher-level language could certainly do this underneath the covers (and I bet out of the many .NET languages today, there are ones already that do).
2. I think in an alternative universe, the CLR also could have handled this too and allowed languages to directly pass properties as by-ref parameters. The CLR's JITter could handled the codegen above and even managing both versions of the target method; and it could even have an optimized way of indirectly calling get and set property methods.