Story Of Pass By Value And Pass By Reference In C#

int num1 = 5;  
int num2 = num1;  
num2 = 10;  
Console.WriteLine(num1);  

private void ChangeValue(int i)   
{  
    i = 10;  
}  

int num1 = 5;  
  
ChangeValue(num1);  
  
Console.WriteLine(num1);  

public class User  
{  
    public int UserID  
    {  
        get;  
        set;  
    }  
    public string Name  
    {  
        get;  
        set;  
    }  
}  

User objUser = new User()   
{  
    UserID = 1,  
        Name = "Ehsan Sajjad"  
};  
User objUser2 = objUser;  
objUser2.Name = "Jon Doe";  

We can see the same behavior using a method. See the following method to change Name property of User object.

public static void ChangeName(User user)  
{  
    user.Name = "Jon Doe";  
} 

We call it to change the object state, it will give the same behavior that we saw in assignment case.

User objUser = new User()  
{  
    UserID = 1, Name = "Ehsan Sajjad"  
};  
  
ChangeName(objUser);  
  
Console.WriteLine(objUser.Name);  

When we are passing reference objUser of User object to method ChangeName, reference of memory location is copied to the local object user of method, but they are both pointing to the same memory location which means they both are having reference to the same memory location, so changing the value of Name property will change the value in the object in memory of which we have reference in objUser and user, hence "Jon Doe" will be printed on console.

Here is a diagrammatic representation of it.

When the ChangeName(objUser) is called, as it is referring to the same memory location, it will modify the Name property of User object to "Jon Doe".

But think about what would happen if I set the user to null inside ChangeName method like.

public static void ChangeName(User user)  
{  
    user = null;  
}  

And now we call it for objUser.

User objUser = new User()  
{  
    UserID = 1,  
        Name = "Ehsan Sajjad"  
};  
  
ChangeName(objUser);  
Console.WriteLine(objUser.Name);

If you are thinking that it will throw Null Reference Exception, then you are wrong, and if you are thinking that it will output Ehsan Sajjad, then you are right and you have understood that reference is passed by value in C# not by reference.

See the pictorial representation to understand better.

Pass By Reference

If we want to make objUser null, we will have to pass it to the method via reference which is done in C# using ref Keyword. We will use the above examples again but this time we will pass them by reference and will see what happens so that we can understand the difference between these two.

Pass By Reference in Value Types

We will use the same above example but this time we will be passing by reference. For that, first of all, we have to change the method signatures of method ChangeValue(inti) to ChangeValue(ref inti), we have added ref keyword with the input parameter which means that when calling this method, the argument should be passed by reference to it:

private void ChangeValue(ref int i)  
{  
    i = 10;  
}  

Now we will use the same code as above but we have to use ref keyword at calling side for the parameters that method expects to be passed by reference, otherwise you will get compile time error, and your code will not build:

int num1 = 5;  
  
ChangeValue(ref num1);  
  
Console.WriteLine(num1);  

This will output 10 on the screen, because we are using ref keyword, in the above code when ChangeValue is called the incoming parameter of it has the same memory address of num1 which is passed as argument that's why now modifying the value of i would reflect the change in num1 as well, in pass by reference new memory location is not used for the method parameter so changing the value of it will reflect the variable that is passed from calling side.

Pass By Reference in Reference Types

We will now check the same thing with reference types, and the behaviour would be the same for reference types case as well, first modify the signature of method so that it takes parameter as reference:

public static void ChangeName(ref User user)   
{  
    user = null;  
}  

and we will call it simply this way.

User objUser = new User()  
{  
    UserID = 1,  
        Name = "Ehsan Sajjad"  
};  
  
ChangeName(objUser);  
Console.WriteLine(objUser.Name); 

Now when we will call it on objUser setting user to null inside ChangeName will also make objUser null because instead of passing the reference by value (in that a new reference memory location is created which points to the same object) it is passed by reference, so in this case new copy of reference is not created but the reference of objUser is passed to method which results in setting the calling side reference to also change the memory location where it is pointing.