Why use the 'ref' keyword when passing an object?

Question

If I am passing an object to a method, why should I use the ref keyword? Isn't this the default behaviour anyway?

For example:

class Program
{
    static void Main(string[] args)
    {
        TestRef t = new TestRef();
        t.Something = "Foo";

        DoSomething(t);
        Console.WriteLine(t.Something);
    }

    static public void DoSomething(TestRef t)
    {
        t.Something = "Bar";
    }
}


public class TestRef
{
    public string Something { get; set; }
}

The output is "Bar" which means that the object was passed as a reference.

Hufford

Answer 1

Pass a ref if you want to change what the object is:

TestRef t = new TestRef();
t.Something = "Foo";
DoSomething(ref t);

void DoSomething(ref TestRef x)
{
  x = new TestRef();
  x.Something = "Not just a changed TestRef, but a completely different TestRef object";
}

After calling DoSomething, t does not refer to the original new TestRef, but refers to a completely different object.

This may be useful too if you want to change the value of an immutable object, e.g. a string. You cannot change the value of a string once it has been created. But by using a ref, you could create a function that changes the string for another one that has a different value.

It is not a good idea to use ref unless it is needed. Using ref gives the method freedom to change the argument for something else, callers of the method will need to be coded to ensure they handle this possibility.

Also, when the parameter type is an object, then object variables always act as references to the object. This means that when the ref keyword is used you've got a reference to a reference. This allows you to do things as described in the example given above. But, when the parameter type is a primitive value (e.g. int), then if this parameter is assigned to within the method, the value of the argument that was passed in will be changed after the method returns:

int v = 1;
Change(ref v);
Debug.Assert(v == 5);
WillNotChange(v);
Debug.Assert(v == 5); // Note: v doesn't become 10

void Change(ref int x)
{
  x = 5;
}

void WillNotChange(int x)
{
  x = 10;
}

Jaco

if I didn't already know the mechanics this answer would be extremely confusing. in the text you refer to t but actually the method parameter AND ALSO the private field are named t. since the answer actually is about, that changing the param actually changes the field's reference itself, i'd strongly suggest different names here! – Shalne

@Shalne hopefully that's better now – Jaco

Answer 2

You need to distinguish between "passing a reference by value", and "passing a parameter/argument by reference".

I've written a reasonably long article on the subject to avoid having to write carefully each time this comes up on newsgroups.

Uretic

Well I encountered the issue while upgrading VB6 into .Net C# code. There are function/method signatures that take ref, out and plain parameters. So how can we better distinguish the difference between a plain param vs a ref? – Theo

@bonCodigo: Not sure what you mean by "better distinguish" - it's part of the signature, and you have to specify ref at the call site as well... where else would you want it to be distinguished? The semantics are reasonably clear too, but need to be expressed carefully (rather than "objects are passed by reference" which is the common over-simplification). – Uretic

Answer 3

In .NET when you pass any parameter to a method, a copy is created. In value types means that any modification you make to the value is at the method scope, and is lost when you exit the method.

When passing a Reference Type, a copy is also made, but it is a copy of a reference, i.e. now you have TWO references in memory to the same object. So, if you use the reference to modify the object, it gets modified. But if you modify the reference itself - we must remember it is a copy - then any changes are also lost upon exiting the method.

As people have said before, an assignment is a modification of the reference, thus is lost:

public void Method1(object obj) {   
 obj = new Object(); 
}

public void Method2(object obj) {  
 obj = _privateObject; 
}

The methods above does not modifies the original object.

A little modification of your example

 using System;

    class Program
        {
            static void Main(string[] args)
            {
                TestRef t = new TestRef();
                t.Something = "Foo";

                DoSomething(t);
                Console.WriteLine(t.Something);

            }

            static public void DoSomething(TestRef t)
            {
                t = new TestRef();
                t.Something = "Bar";
            }
        }



    public class TestRef
    {
    private string s;
        public string Something 
        { 
            get {return s;} 
            set { s = value; }
        }
    }

Heeley

but the properties of the object are lost in "t = new TestRef();". this does not answer the question properly. – Matchbox

Answer 4

Since TestRef is a class (which are reference objects), you can change the contents inside t without passing it as a ref. However, if you pass t as a ref, TestRef can change what the original t refers to. i.e. make it point to a different object.

Pep

Answer 5

With ref you can write:

static public void DoSomething(ref TestRef t)
{
    t = new TestRef();
}

And t will be changed after the method has completed.

Kansas

And if ref was not specified then t is the same object with all properties reset to initial values. As far as the caller is concerned, the passed in argument will always have properties reset. What's the point of doing this? – Quasijudicial

Answer 6

This is like passing a pointer to a pointer in C. In .NET this will allow you to change what the original T refers to, personally though I think if you are doing that in .NET you have probably got a design issue!

Lotte

Answer 7

Think of variables (e.g. foo) of reference types (e.g. List<T>) as holding object identifiers of the form "Object #24601". Suppose the statement foo = new List<int> {1,5,7,9}; causes foo to hold "Object #24601" (a list with four items). Then calling foo.Length will ask Object #24601 for its length, and it will respond 4, so foo.Length will equal 4.

If foo is passed to a method without using ref, that method might make changes to Object #24601. As a consequence of such changes, foo.Length might no longer equal 4. The method itself, however, will be unable to change foo, which will continue to hold "Object #24601".

Passing foo as a ref parameter will allow the called method to make changes not just to Object #24601, but also to foo itself. The method might create a new Object #8675309 and store a reference to that in foo. If it does so, foo would no longer hold "Object #24601", but instead "Object #8675309".

In practice, reference-type variables don't hold strings of the form "Object #8675309"; they don't even hold anything that can be meaningfully converted into a number. Even though each reference-type variable will hold some bit pattern, there is no fixed relationship between the bit patterns stored in such variables and the objects they identify. There is no way code could extract information from an object or a reference to it, and later determine whether another reference identified the same object, unless the code either held or knew of a reference that identified the original object.

Gyatt

Don't reference type variables hold IntPtrs? Couldn't you do IntPtr.ToString() to get the memory address? – Folliculin

@DavidKlempfner: The .NET runtime needs to know at every point during program execution of at least one reference to every pinned object, and every reference to every unpinned object. By my understanding, if one passes an object field as a ref parameter, the system will keep track of what parts of the stack frame hold ref parameters, as well as references to the objects whose fields are accessed in such fashion; in at least some versions of the .NET gc. the it's possible for the system to relocate an object whose field is identified by a byref, and update the byref appropriately. – Gyatt

@DavidKlempfner: I think it's possible to pin an object to which a byref is held, and then convert the byref to an IntPtr that would remain valid as long as the object is pinned, but knowledge of an object's address at some point in time will only be meaningful if the object has been pinned continuously since the address was observed. – Gyatt

@DavidKlempfner: It's been ages since I read about how such things were done and did some experiments. The most important principle to understand is that if an object gets relocated, every reference that might ever be used to access that object will have the stored bit pattern updated to reflect the new location. A concurrent GC might set access-control bits so that an attempt to access an object at the old location would trigger a bus fault, and then have the bus fault handler update the address to reflect the new location, but the old storage would not be eligible for reclamation... – Gyatt

...until all copies of the old address have been replaced with the new one. It's a system which would seem like it should be complicated and inefficient, but commonplace versions of both the JVM and .NET Runtime are able to use some clever techniques to make things work surprisingly well. – Gyatt

Answer 8

By using the ref keyword with reference types you are effectively passing a reference to the reference. In many ways it's the same as using the out keyword but with the minor difference that there's no guarantee that the method will actually assign anything to the ref'ed parameter.

Hitchcock

Answer 9

ref mimics (or behaves) as a global area just for two scopes:

• Caller
• Callee.

Selfservice

Answer 10

If you're passing a value, however, things are different. You can force a value to be passed by reference. This allows you to pass an integer to a method, for example, and have the method modify the integer on your behalf.

Khosrow

Whether you're passing a reference or a value type value, the default behaviour is to pass by value. You just need to understand that with reference types, the value you're passing is a reference. This isn't the same as passing by reference. – Uretic

Answer 11

I believe somewhere I read a beautiful description about related behaviour. It goes something like this:

In C# there is no "pass by reference" as there are no pointers (except unsafe code), actually everything is "copy by value". Only that instances of complex types should actually be seen as variables holding a reference as value. As such they "value" (which is a reference pointing to the real data) is copied on method calls. So inside the method the parameter references the same object, but the variable holding the reference is a copy of the original input. ref keyword changes this to call by reference.

official doku

official doku continued

Shalne