Passing a class as a ref parameter in C# does not always work as expected. Can anyone explain?

Question

I always thought that a method parameter with a class type is passed as a reference parameter by default. Apparently that is not always the case. Consider these unit tests in C# (using MSTest).

[TestClass]
public class Sandbox
{
    private class TestRefClass
    {
        public int TestInt { get; set; }
    }

    private void TestDefaultMethod(TestRefClass testClass)
    {
        testClass.TestInt = 1;
    }

    private void TestAssignmentMethod(TestRefClass testClass)
    {
        testClass = new TestRefClass() { TestInt = 1 };
    }

    private void TestAssignmentRefMethod(ref TestRefClass testClass)
    {
        testClass = new TestRefClass() { TestInt = 1 };
    }

    [TestMethod]
    public void DefaultTest()
    {
        var testObj = new TestRefClass() { TestInt = 0 };
        TestDefaultMethod(testObj);
        Assert.IsTrue(testObj.TestInt == 1);
    }

    [TestMethod]
    public void AssignmentTest()
    {
        var testObj = new TestRefClass() { TestInt = 0 };
        TestAssignmentMethod(testObj);
        Assert.IsTrue(testObj.TestInt == 1);
    }

    [TestMethod]
    public void AssignmentRefTest()
    {
        var testObj = new TestRefClass() { TestInt = 0 };
        TestAssignmentRefMethod(ref testObj);
        Assert.IsTrue(testObj.TestInt == 1);
    }
}

The results are that AssignmentTest() fails and the other two test methods pass. I assume the issue is that assigning a new instance to the testClass parameter breaks the parameter reference, but somehow explicitly adding the ref keyword fixes this.

Can anyone give a good, detailed explanation of whats going on here? I'm mainly just trying to expand my knowledge of C#; I don't have any specific scenario I'm trying to solve...

Answer 1

How "Pass By Value" in Methods Works for References in C#

There are lot's of subtleties missed in the posted answers here that will create unexpected results and confuse new C# developers. All methods in C# use "pass by value" by default. True Value Types like numbers and Structs are copied and that "value" passed in. The same rules apply for references. But a special value for references are copied. Please read on...

All methods in C# pass arguments in BY VALUE by default unless you use the ref, in, or out keywords. Passing a REFERENCE BY VALUE means a COPY of the MEMORY ADDRESS of the object used by the outside reference is passed in and assigned to the method parameter. The original outside variable address is not passed in nor the original object in memory, just a copy of the memory pointer or address to the object.

Both variables now point to the same object in memory.

This copy of the address to the object in memory is the VALUE for pass by value for all reference types. That means the original reference variable that points to the object address remains the same, and a new copy of that memory address to the object is assigned to a new method parameter. The method parameter and your original object variable now point to the same object in memory in the heap. BOTH point to the same object. That means if either change properties on the object, it will affect your outside variable and the parameter inside the method.

This seems to act like a PASS BY REFERENCE, but it is not. That is what confuses many developers.

But this means some "weird" and unexpected things can happen passing a reference by value in methods if you are not careful. It means your method variable can connect to the same object and change the properties and fields of the original shared object ...BUT... as soon as you reassign the method variable to a new instance of the same type of object, it loses a connection to the original instance and no longer affects the original object used by the outside reference.

You might assume the method has assigned a fresh object to the outside reference variable, but you have not! Changing that new object's properties in the method no longer affect the outside reference. So BE CAREFUL!

Let's test this weirdness in C#:

// First, create my cat class. I can change its name 
// to anything I want. But instead, I want it to have 
// a special name assigned by the next class via a method.

class MyCat
{
    public string Name { get; set; }
}


// This special class will assign a popular name to my cat.

class CatNames
{
    public enum PopularNames {
        Felix,
        Fluffy
    }

    public void ChangeName(MyCat c)
    {
        PopularNames p = PopularNames.Felix;

        c.Name = p.ToString();
    }

    public void ChangeNameAndCat(MyCat c)
    {
        PopularNames p = PopularNames.Fluffy;

        MyCat d = new MyCat();
        d.Name = p.ToString();

        // Here is the magic! "c" is now reassigned to a new 
        // memory address to a new object. So the original
        // object pointer "c" was assigned to is lost and
        // replaced with one for "d". The original object is
        // still assigned to your outside variable that
        // called this method, however.
        c = d;

    }
}

// Testing passing by value and how references are passed...

CatNames catnamechanger = new CatNames();

// I created two cats with the same name so you can see 
// what names actually changed below.

MyCat cat1 = new MyCat();
cat1.Name = "Bubba";
MyCat cat2 = new MyCat();
cat2.Name = "Bubba";

catnamechanger.ChangeName(cat1);
catnamechanger.ChangeNameAndCat(cat2);

Console.WriteLine("My Cat1's Name is: " + cat1.Name);
Console.WriteLine("My Cat2's Name is: " + cat2.Name);

// ============== OUTPUT ==================
// My Cat1's Name is: Felix 
// My Cat2's Name is: Bubba <<< OOPS! My cat name kept the original

RESULTS

Notice the first cat had its name changed on the original object, but the second cat kept its original name, "Bubba", as a new cat was assigned to the method variable. It lost connection to the original object. The reason is, passing a reference by value still allows you to affect properties of the passed in address to the original object. But as soon as you change where the method variable points, that reference is lost.

Answer 2

My 2 cents

When a class is passed to a method, a copy of its memory space address is being sent (a direction to your house is being sent). So any operation on that address will affect the house but will not change the address itself. (This is default).

Passing a class (object) by reference has an effect of passing its actual address instead of a copy of an address. That means if you assign a new object to an argument passed by reference it will change the actual address (similar to relocation). :D

This is how I see it.

Answer 3

The thing that is nearly always forgotten is that a class isn't passed by reference, the reference to the class is passed by value.

This is important. Instead of copying the entire class (pass by value in the stereotypical sense), the reference to that class (I'm trying to avoid saying "pointer") is copied. This is 4 or 8 bytes; much more palatable than copying the whole class and in effect means the class is passed "by reference".

At this point, the method has it's own copy of the reference to the class. Assignment to that reference is scoped within the method (the method re-assigned only its own copy of the reference).

Dereferencing that reference (as in, talking to class members) would work as you'd expect: you'd see the underlying class unless you change it to look at a new instance (which is what you do in your failing test).

Using the ref keyword is effectively passing the reference itself by reference (pointer to a pointer sort of thing).

As always, Jon Skeet has provided a very well written overview:

http://www.yoda.arachsys.com/csharp/parameters.html

Pay attention to the "Reference parameters" part:

Reference parameters don't pass the values of the variables used in the function member invocation - they use the variables themselves.

If the method assigns something to a ref reference, then the caller's copy is also affected (as you have observed) because they are looking at the same reference to an instance in memory (as opposed to each having their own copy).

Answer 4

The AssignmentTest uses TestAssignmentMethod which only changes the object reference passed by value.

So the object itself is passed by reference but the reference to the object is passed by value. so when you do:

testClass = new TestRefClass() { TestInt = 1 };

You are changing the local copied reference passed to the method not the reference you have in the test.

So here:

[TestMethod]
public void AssignmentTest()
{
    var testObj = new TestRefClass() { TestInt = 0 };
    TestAssignmentMethod(testObj);
    Assert.IsTrue(testObj.TestInt == 1);
}

testObj is a reference variable. When you pass it to TestAssignmentMethod(testObj);, the refernce is passed by value. so when you change it in the method, original reference still points to the same object.

Answer 5

The default convention for parameters in C# is pass by value. This is true whether the parameter is a class or struct. In the class case just the reference is passed by value while in the struct case a shallow copy of the entire object is passed.

When you enter the TestAssignmentMethod there are 2 references to a single object: testObj which lives in AssignmentTest and testClass which lives in TestAssignmentMethod. If you were to mutate the actual object via testClass or testObj it would be visible to both references since they both point to the same object. In the first line though you execute

testClass = new TestRefClass() { TestInt = 1 }

This creates a new object and points testClass to it. This doesn't alter where the testObj reference points in any way because testClass is an independent copy. There are now 2 objects and 2 references which each reference pointing to a different object instance.

If you want pass by reference semantics you need to use a ref parameter.