It is a common question which is asked by interviewers in interviews that "What is Pass By Value and Pass By Reference" or "What is the difference between Pass By Value and Pass By Reference". Most of the beginner level developers and also many of intermediate level developers have misconception on it and they answer it wrong during interview.

When i didn't knew that real difference, i used to answer it like, when we pass primitive types they are passed by value but when we pass reference type, they are passed by reference which i was not aware that it is wrong.

So, today i decided to write on this topic so that readers reading my blog could be aware of the real difference and they can correct their misconception regarding it.

In .Net Framework all objects are by default passed by value not passed by reference either it is a Value Type (so called Primitive types like int,char,double etc) or Reference Type (class,interface,delegate,string etc).

I will not go in to the details of Value Type and Reference Type definition and concept, you can read about them here.

Consider the following Examples:

First i will show a example using Value Type.

int num1 = 5;
int num2 = num1;
num2 = 10;

Console.WriteLine(num1);

So what will be printed on Console?

If your answer is 5,then you are right, because int is a value type, it is passed by value, which means for the above code num1 has 5 stored in it, when we create num2 and assign it num1 value of num1 is copied to num2 and after that if we change num2 it will not affect num1, ofcourse because we have copied value of num1 to num2, why num1 is to be change.

The same happens when we pass value types to methods. For Example:

We have created a method with sets the value of a int variable to 10.

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

Now we call it using our previous example:

int num1 = 5;

ChangeValue(num1);
           
Console.WriteLine(num1);

What would be the output on Console now?

Yes it will still output 5 as i already said that value is copied, so when ChangeValue method is called, num1 variable value is copied to i  so changing i does not changes num1.

Here is diagrammatic representation of Pass By Value.

 I have following class of User which is a reference type as classes are reference types :

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

we create an instance and set its properties then we assign it to another instance and change Name property and then we print Name on Console to check what is printed:

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

User objUser2 = objUser;
objUser2.Name = "Jon Doe";

When we create Instance of class User, an object is create in memory(Heap) and memory is allocated to it and we are storing reference to that memory location in objUser reference memory (mostly Stack) so that we can use it further, otherwise it will get lost in the memory so we need to keep a reference to it for doing different operation in memory.

When we assign objUser to objUser2 reference of object memory location which objUser is holding copied to objUser2 , now we have two seperate copies of reference but they are both are pointing to same memory location which means they both are referencing to 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 objUser, hence "Jon Doe" will be printed on console and it will be reflected in both references.

Diagrammatic/Pictorial Representation of Pass By Value in Reference Types:

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 what 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 are pointing to same memory location which means they both are having reference to same memory location,so changing the value 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 diagramatic representation of it:

When the ChangeName(objUser) is called, as it is referring to 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 are passed by value in C# not by reference.

See the pictorial representation to understand better:

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 inderstand the difference between these two.

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(int i) to ChangeValue(ref int i), 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 expect 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.

We will now check the same thing with reference types, and the behaviour would be 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 create which points 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 setting the calling side reference to also change the memory location where it is pointing.