Question

Could you please explain the following behavior of C# Class. I expect the classResult as “Class Lijo”; but actual value is “Changed”.

We’re making a copy of the reference. Though the copy is pointing to the same address, the method receiving the argument cannot change original.

Still why the value gets changed ?

public partial class _Default : Page 
{
    protected void Page_Load(object sender, EventArgs e)
    {
        String nameString = "string Lijo";

        Person p = new Person();
        p.Name = "Class Lijo";

        Utilityclass.TestMethod(nameString, p);
        string classResult = p.Name;
        Response.Write(nameString + "....." + classResult);
    }
}

public class Utilityclass
{
    public static void TestMethod(String nameString, Person k)
    {
        nameString = "Changed";
        k.Name = "Changed";
    }
}

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

Update: When I pass a String, it does not get actually changed.

Answer 1

The briefest answer is: read my article on parameter passing which goes into this in a fair amount of detail.

The slightly longer answer is to compare these two methods, both of which use value parameters:

public void ChangeMe(string x)
{
    x = "changed";
}

public void ChangeMe(Person x)
{
    x.Name = "changed";
}

In the first case, you are changing the value of the parameter. That is completely isolated from the original argument. You can’t change the content of the string itself, because strings are immutable.

In the second case, you are changing the contents of the object which the parameter’s value refers to. That’s not changing the value of the parameter itself – it will be the same reference. To give a real world example, if someone delivers something to your house that changes the contents of your house, but it doesn’t change your house’s address.

If you changed the second method to this:

public void ChangeMe(Person x)
{
    x = new Person("Fred");
}

then the caller wouldn’t see any change. This is closer to what you’re doing with a string – you’re making the parameter refer to a different object, rather than changing the contents of the existing object.

Now, when you use a ref parameter, the variable used by the caller as the argument is “aliased” with the parameter – so if you change the value of the parameter, that changes the value of the argument as well. So if we change the last method like this:

public void ChangeMe(ref Person x)
{
    x = new Person("Fred");
}

then:

Person y = new Person("Eric");
ChangeMe(ref y);
Console.WriteLine(y.Name);

this will print out “Fred”.

The key concept to understand is that the value of a variable is never an object – it’s either a value type value or a reference. If an object’s data is changed, that change will be visible through other references. Once you understand that copying a reference isn’t the same as copying an object, the rest falls into place reasonably easily.