Pass by value versus reference in C#

Functions in C# may have a sequence of parameters. There are 3 ways a parameter can be passed into a function:

• Pass by value (default way – no prefix; assumes that the variable value is set before the function is called)
• Pass by reference (prefix with keyword ref; assumes that the variable value is set before the function is called)
• Pass by reference (prefix with keyword out; assumes that the variable value will be set by the calling function)

When a variable is passed by reference using ref modifier, both the variables point to the same memory location. Note, that 2 variables do get created; but they point to the same memory location pointing at the same object. To use a ref parameter, both the method definition and the calling method must explicitly use the ref keyword.

Similarly, the out keyword causes arguments to be passed by reference. This is like the ref keyword, except that ref requires that the variable be initialized before it is passed. To use an out parameter, both the method definition and the calling method must explicitly use the out keyword.

Let's now review this simple series of functions to review the important differences between pass by value, pass by reference using ref and pass by reference using out. Also note the differences in behavior for value types and objects when passed to functions.

using System;

namespace SimpleCodingQuestions
{
    class Program
    {
        /// <summary>
        /// When a value type is passed by value
        /// changes to the passed parameter
        /// does not affect the original value
        /// </summary>
        /// <param name="input"></param>
        public static void PassByValue(int input)
        {
            input = input + 10;
            Console.WriteLine("In function PassByValue: input = {0}", input);
        }

        /// <summary>
        /// when a value is passed by reference
        /// any changes to the parameter in the 
        /// function affects the parameter
        /// outside the function
        /// </summary>
        /// <param name="input"></param>
        public static void PassByRef(ref int input)
        {
            input = input + 50;
            Console.WriteLine("In function PassByRef: input = {0}", input);
        }

        /// <summary>
        /// when a value is passed by reference
        /// any changes to the parameter in the 
        /// function affects the parameter
        /// outside the function
        /// </summary>
        /// <param name="input"></param>
        public static void PassByOut(out int input)
        {
            // when out is used, the parameter needs to be
            // initialized before it can be used
            input = 75;
            Console.WriteLine("In function PassByOut: input = {0}", input);
        }

        /// <summary>
        /// When objects are passed, they are implicitly passed
        /// as reference
        /// any changes made in the function
        /// will reflect outside also
        /// </summary>
        /// <param name="emp"></param>
        public static void PassingObjectsByValue(Employee emp)
        {
            emp.Name = "PassingObjectsByValue";
            Console.WriteLine("In function PassingObjectsByValue: employee name = {0}", emp.Name);
        }

        /// <summary>
        /// When objects are passed, they are implicitly passed
        /// as reference
        /// any changes made in the function
        /// will reflect outside also
        /// THE REF KEYWORD IS NOT NEEDED HERE
        /// IT IS EXACTLY THE SAME AS ABOVE FUNCTION
        /// </summary>
        /// <param name="emp"></param>
        public static void PassingObjectsByRef(ref Employee emp)
        {
            emp.Name = "PassingObjectsByRef";
            Console.WriteLine("In function PassingObjectsByRef: employee name = {0}", emp.Name);
        }

        static void Main(string[] args)
        {
            // demo of passing value types vy value, ref and out
            int input = 5;
            Console.WriteLine("In Main: input = {0}", input);
            PassByValue(input);
            Console.WriteLine("In Main after calling PassByValue: input = {0}\n", input);
            PassByRef(ref input);
            Console.WriteLine("In Main after calling PassByRef: input = {0}\n", input);
            PassByOut(out input);
            Console.WriteLine("In Main after calling PassByOut: input = {0}\n", input);

            // demo of passing objects by value and ref
            Employee emp = new Employee() { Id = 5, Name = "Test" };
            Console.WriteLine("In Main: Employee Name = {0}", emp.Name);
            PassingObjectsByValue(emp);
            Console.WriteLine("In Main after calling PassingObjectsByValue: Employee Name = {0}\n", emp.Name);
            PassingObjectsByRef(ref emp);
            Console.WriteLine("In Main after calling PassingObjectsByRef: Employee Name = {0}\n", emp.Name);
        }
    }

    /// <summary>
    /// Dummy class for demonstrating passing objects
    /// </summary>
    class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

I know this is a long program but note the functions, their invocations in the main and the corresponding output below.

 

As you can see, PassByValue() function's changes to the local variable did not affect the main value, but passing by ref and passing by out did change the value in the main() function. Also, note that objects are inherently passed by reference.