Reference parameters

Reference parameters don't pass the values of the variables used in the function member invocation - they use the variables themselves. Rather than creating a new storage location for the variable in the function member declaration, the same storage location is used, so the value of the variable in the function member and the value of the reference parameter will always be the same.

 Reference parameters need the ref modifier as part of both the declaration and the invocation - that means it's always clear when you're passing something by reference. Let's look at our previous examples, just changing the parameter to be a reference parameter:

void Foo(ref StringBuilder x)
{
    x = null;

}

...

StringBuilder y = new StringBuilder();
y.Append ("hello");
Foo (ref y);
Console.WriteLine (y==null);

EXAMPLE

using System;
using System.Text;

public class Example6
{
    // Note that Foo is declared static here just
    // to make the sample app simple, so we don't
    // need to instantiate the example class. This
    // has no bearing on the parameter passing
    // discussed
    static void Foo (ref StringBuilder x)
    {
        x = null;
    }

    public static void Main (string[] args)
    {
        StringBuilder y = new StringBuilder();
        y.Append ("hello");
        Foo (ref y);
        Console.WriteLine (y==null);
    }

}

Output:
True

Here, because a reference to y is passed rather than its value, changes to the value of parameter x are immediately reflected in y. In the above example, y ends up being null. Compare this with the result of the same code without the ref modifiers. Now consider the struct code we had earlier, but using reference parameters:

void Foo (ref IntHolder x)
{
    x.i=10;

}

...

IntHolder y = new IntHolder();
y.i=5;
Foo (ref y);
Console.WriteLine (y.i);

EXAMPLE

using System;
using System.Text;

public class Example7
{
    struct IntHolder
    {
        public int i;
    }

    // Note that Foo is declared static here just
    // to make the sample app simple, so we don't
    // need to instantiate the example class. This
    // has no bearing on the parameter passing
    // discussed
    static void Foo (ref IntHolder x)
    {
        x.i=10;
    }

    public static void Main (string[] args)
    {
        IntHolder y = new IntHolder();
        y.i=5;
        Foo (ref y);
        Console.WriteLine (y.i);
    }

}

Output:
10

The two variables are sharing a storage location, so changes to x are also visible through y, so y. i has the value 10 at the end of this code.

Note: what is the difference between passing a value object by reference and a reference object by value?

 You may have noticed that the last example, passing a struct by reference, had the same effect in this code as passing a class by value. This doesn't mean that they're the same thing, however.

Consider the following code:

void Foo (??? IntHolder x)
{
    x = new IntHolder();

}

...

IntHolder y = new IntHolder();
y.i=5;
Foo (??? y);

In the case where IntHolder is a struct (i.e. a value type) and the parameter is a reference parameter (i.e. replace ??? with ref above), y ends up being a new IntHolder value - i.e. y.i is 0. In the case where IntHolder is a class (i.e. a reference type) and the parameter is a value parameter (i.e. remove ??? above), the value of y isn't changed - it's a reference to the same object it was before the function member call.

 This difference is absolutely crucial to understanding parameter passing in C#, and is why I believe it is highly confusing to say that objects are passed by reference by default instead of the correct statement that object references are passed by value by default.