Question

This is issue about LANGUAGE DESIGN.

Please do not answer to the question until you read entire post! Thank you.

With all helpers existing in C# (like lambdas, or automatic properties) it is very odd for me that I cannot pass property by a reference. Let’s say I would like to do that:

foo(ref my_class.prop);

I get error so I write instead:

{
   var tmp = my_class.prop;
   foo(tmp);
   my_class.prop = tmp;
}

And now it works. But please notice two things:

1. it is general template, I didn’t put anywhere type, only “var”, so it applies for all types and number of properties I have to pass

2. I have to do it over and over again, with no benefit — it is mechanical work

The existing problem actually kills such useful functions as Swap. Swap is normally 3 lines long, but since it takes 2 references, calling it takes 5 lines. Of course it is nonsense and I simply write “swap” by hand each time I would like to call it. But this shows C# prevents reusable code, bad.

THE QUESTION

So — what bad could happen if compiler automatically create temporary variables (as I do by hand), call the function, and assign the values back to properties? Is this any danger in it? I don’t see it so I am curious what do you think why the design of this issue looks like it looks now.

Cheers,

EDIT As 280Z28 gave great examples for beating idea of automatically wrapping ref for properties I still think wrapping properties with temporary variables would be useful. Maybe something like this:

Swap(inout my_class.prop1,inout my_class.prop2);

Otherwise no real Swap for C# 🙁

Answer 1

There are a lot of assumptions you can make about the meaning and behavior of a ref parameter. For example,

Case 1:

int x;
Interlocked.Increment(ref x);

If you could pass a property by ref to this method, the call would be the same but it would completely defeat the semantics of the method.

Case 2:

void WaitForCompletion(ref bool trigger)
{
    while (!trigger)
        Thread.Sleep(1000);
}

Summary: A by-ref parameter passes the address of a memory location to the function. An implementation creating a temporary variable in order to “pass a property by reference” would be semantically equivalent to passing by value, which is precisely the behavior that you’re disallowing when you make the parameter a ref one.