Should value or reference be used, when both work the same?

Question

If you have a method, one that takes in a variable, and doesn't actually modify the physical variable at all, should you use ref to reference the input parameter? It shouldn't really matter, because the variable isn't modified anyway, so what are the disadvantages/advantages of using ref? (in C# at least)

For example,

int[] numbers = new int[] { /* some numbers */ };
int getNumberValue(int index)
{
    return numbers[index];
}
int getNumberRef(ref int index)
{
    return numbers[index];
}

Why would you prefer any of the two methods over the other? They both work the same, since the parameter is never modified...

I would think that the ref version would be quicker if I used it 18 billion times, since the value version probably makes a clone of the parameter so the method can modify it (but I may be wrong), although there could be some disadvantages.

Answer 1

They're functionally equivalent, but they're semantically very different.

A method with a signature such as Method(ref string s) tells clients it may need to assign s a new value. The client will consequently act upon this false assumption, and do things he doesn't need to, such as checking if s is null after calling your method, or some other kind of validation.

Also, as a general programming advice, don't use things you don't need! You're adding unnecessary complexity, you're gonna confuse yourself and others. This is the sort of behaviour that leads to cargo cult programming.

Answer 2

Useful answer: you almost never need to use ref/out. It's basically a way of getting another return value, and should usually be avoided precisely because it means the method's probably trying to do too much. That's not always the case (TryParse etc are the canonical examples of reasonable use of out) but using ref/out should be a relative rarity.

More info here.

Answer 3

You dont use ref that way. ref really changes the reference of the variable passed. So you use this when you need it. Simple as that.

Unless you dont need a function or method to change the reference, you shouldnt use it at all, and usually its a good idea to avoid ref.

Ref works like this:

 int a = 5;
 int b = 6;


 _swap(ref a, ref b);


 // a is now 6 and b is now 5;

This is the Swap-Method:

 void _swap(ref int a, ref int b)
 { 
     int tmp = a;
     a = b;
     b = tmp;
 }

Test it here