Is there a good reason to ever pass a ref string or ref class to a function?

Question

A coworker and i were debating today whether or not it is ever useful to make this sort of a function:

private void MyFunction(ref MyClass variable)
    {

    }

The only advantage i can see is that it would allow you to set the original pointer to the variable to null... outside of that there would be no difference if you omitted the ref, correct?

Can you think of any reason to ever pass a ref string to a function?

Answer 1

Personally I'd prefer to return a Tuple with multiple values, but the basic point is to give multiple results to the caller. In the case of a ref parameter, the extra result will potentially replace the value in an existing variable. Note that this is very different to just working on the parameter itself. For example:

public void Foo(ref StringBuilder builder)
{
    builder = new StringBuilder("hello");
}

is completely different to:

public void Foo(StringBuilder builder)
{
    builder.Clear();
    build.Append("hello");
}

Whether the parameter type is a reference type or a value type is somewhat irrelevant - particularly when you consider immutable types such as string, where there's no equivalent to the latter approach above.

Answer 2

The TryParse and TryGetValue family of methods?

Get a value and an indication of success, without having to parse/search twice.

I've used this myself to split and address into a street and housenumber. Within the method I have both, if I only have a return value, I would have to split the data twice.

The example you use does not look usefull, except in an interop context.

Answer 3

Here's a brief example.

private void MyFunction(ref MyClass variable)
{
  variable = new MyClass();
  // You just changed the variable that was passed,
  // even outside the scope of this method!
}

private void MyFunction(MyClass variable)
{
  variable = new MyClass();
  // Without ref, the variable is still intact
  // outside of this scope.
}

Answer 4

Sometimes you want to return a value and update an object at the same time:

// Converts specified brush to grayscale. Returns `true` on success,
// or `false` if the brush is already grayscale.
public bool MakeBrushGrayscale(ref SolidBrush brush)
{
    if (IsGrayscale(brush.Color)) {
        return false;
    }

    brush = new SolidBrush(GetGrayscaleColor(brush.Color));
    return true;
}

Answer 5

Sometimes you might want to change the object reference. Imagine a method called Reload(object o) that reloads an object with the data from the database. You can get a new instance of the object from your data access layer (different from the original reference - it does not support identity map) and need to return it to the user.

You have 2 choices here:

object Reload(object o)
{
    return dao.GetById(IdHelper.GetId(o));
}

or

void Reload(ref object o)
{
    o = dao.GetById(IdHelper.GetId(o));
}

Some people might consider the former to be a better design. However, it has a problem. Developers using it might forget to assign the return value to the variable thinking that the object passed into the method will be changed. The ref attribute makes it impossible to use the second method version incorrectly.

Answer 6

I can't argue this is a good reason, but if you were going to pin it and manipulate the raw data of the string (maybe your function is passing it off to some encryption method that is swapping the characters around).

Answer 7

I think that using ref everywhere is bad practice.

1. Good practice is don't give more than necessary.
2. When you use ref you cann't pass null to the method.