Top 5 Difference between Call by Value and Call by Reference

Last updated on September 30th, 2023 at 02:02 am

In this post, we’ll look at a simple but difficult interview question in C#: Call By Value vs Call By Reference.

This is a question that both fresher and experienced developers are asked in interviews. It’s one of the most frequently asked questions by technical interviewers.

In C#, arguments can be passed to the method parameters either by value or by reference. It’s important to remember that C# types can be reference types (like classes, string, interface) or value types (like structs, int).

Pass by Value means sending a copy of the variable’s value to the method.
This means that any modifications made to the parameter within the method won’t affect the original variable outside of it.
Value types, like int, float, and structs, are typically passed by value.

Pass by Reference means you’re providing the method with direct access to the original variable.
This means that any changes made to the parameter within the method will directly impact the original variable outside of it.
Reference types, such as classes, are commonly passed by reference.

In C#, you explicitly specify whether you’re passing an argument by reference using the ref or out keywords. This can be helpful when you want to modify the original value within a method and have those changes reflected outside the method.

It’s important to remember that in C#, all objects are passed by value by default, not by reference, regardless of whether they’re Value Types or Reference Types.

What is call by Reference in C#?

In the call-by-reference mechanism, instead of passing a copy of the actual value the address or reference of a variable is passed as a function parameter.
This means any changes made to the passed values are permanent and directly impact the original variable.

In C#, to specify a reference type parameter, you must use the ref keyword during both the parameter declaration and the method call.

The ref keyword is useful for passing the function a reference to the arguments rather than duplicating the actual value.

This approach is particularly useful when you want changes made within a function to reflect in the original variable outside the function.

C# Pass By Reference Example:

The following is the C# code example demonstrating call-by-reference using ref keyword.

using System;

namespace CallByReferenceExample
{
    class Program
    {
        // Define a method that takes an integer by reference using ref keyword
        static void ModifyValue(ref int number)
        {
            // Multiply the original value by 2
            number *= 2;
        }

        static void Main(string[] args)
        {
            
            // The variable must be initialized first in case of ref keyword.
            int originalValue = 10;

            // Display the original value
            Console.WriteLine("Original Value: " + originalValue);

            // Call the ModifyValue method by reference
            ModifyValue(ref originalValue);

            // Display the modified value
            Console.WriteLine("Modified Value: " + originalValue);

            // Pause execution to see the result
            Console.ReadLine();
        }
    }
}

Output:

Original Value: 10
Modified Value: 20

Code Explanation:

1. We define a ModifyValue method that takes an integer argument by reference using the ref keyword. This means any changes made to the number parameter inside the method will directly affect the original variable passed to it.
2. In the Main method, we initialize an integer variable originalValue with the value 10.
3. We display the original value using Console.WriteLine.
4. We call the ModifyValue method and pass originalValue as an argument by reference using ref originalValue. This allows the method to modify the original value directly.
5. After calling the method, we display the modified value, which is now doubled.

Note: To use the ref argument in a C# program, it is important to explicitly include the ref keyword in both the method declaration and the method call.

What is call by Value in C#?

Call by value in C# is a parameter-passing mechanism where the values of the arguments or parameters are copied and passed to a method or function.

In call by value, any changes made to the parameter values within the method do not affect the original values of the variables used as arguments.

It means that modifications inside the method are isolated and don’t impact the external variables.

Note: The Value-Type variables will store the value of the variable directly in memory, whereas Reference-Type variables will save a reference to the data.

C# Call By Value Example:

using System;
namespace CallByValueExample
{
    class Program
    {
        // Pass by value example
        public static void IncrementValue(int i)
        {
            i ++;
        }
        static void Main(string[] args)
        {
            int x = 100; 
            IncrementValue(x);
            Console.WriteLine(x);
            Console.ReadKey();
            // Output: 100
        }
    }
}

As shown in the above result, the changes made inside of the method have not affected the original value of the variable.

Note: When you intend to use pass-by-reference, you must use either the out or ref keyword, irrespective of whether the argument type is a value type or a reference type.

In such cases, because the parameter shares the same storage location as the argument, any modifications to the parameter within the method will directly affect the original variable.

Call by Value VS Call by Reference

here’s a comparison table with your provided information, rephrased for clarity:

Read more about ref and out keyword in C#.

What is the Difference between Call by Value and Call by Reference in C#?

In C#, the key difference between Call by Value and Call by Reference lies in how method arguments are passed:

1. Call by Value:
   • In Call by value, the values of arguments are copied and passed to the method.
   • Any changes made to these copies within the method do not affect the original variables used as arguments.
   • It’s the default method of passing parameters in C#.
2. Call by Reference:
   • In Call by reference, the actual variables or their reference addresses are passed to the method.
   • Any modifications made to these arguments within the method directly affect the original variables outside the method.
   • Call by Reference requires the use of ref or out keywords to indicate that the method will operate on the actual variables rather than copies.

FAQs

References: MSDN-Passing Parameters (C# Programming Guide) | Call by Value and Call by Reference

Thank you for taking the time to read the blog; if you found it useful, please leave a comment and share it with others.

Articles to Check Out:

• Difference between Ref and Out keywords in C#
• C# Abstract class Vs Interface
• C# Struct vs Class
• Static vs Singleton in C#: Understanding the Key Differences
• Top 50 C# Interview Questions And Answers For Freshers And Experienced
• C# 10 new features
• Understanding Covariance And Contravariance in C#
• C# StreamReader and StreamWriter Example
• C# Tutorial

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024
• How to Reverse an Array in C# with Examples - February 12, 2024