Difference between Ref and Out keywords in C#

Last updated on July 12th, 2023 at 01:04 am

The main difference between ref and out keyword is that ref requires the variable to be initialized before being passed to the method, whereas out does not. Additionally, out enforces that the variable must assign a value inside the method.

C# Ref vs Out

In C#, both the ref and out keywords are used to pass arguments to methods by reference instead of by value. However, there is a slight difference between them.

Ref keyword:

The ref keyword is used to pass an argument by reference. That means It allows the called method to change the argument’s value, and these changes will reflect in the original variable in the calling method. However, it’s important to initialize the variable before passing it to the method.

• When using ref, the variable being passed must be initialized before being passed to the method.
• It allows two-way communication between the method and the calling code. Any changes made to the parameter inside the method will be reflected in the calling code.
• The method can access the value of the variable passed in, but it doesn’t have to assign a new value to it.

Out keyword:

In C#, the out keyword is used to pass arguments to a method by reference.

We use the out keyword when we want a method to return multiple values. By using out keyword, we can pass variables to the method that are initially uninitialized, and the method is responsible for assigning values to those variables before it completes execution. 

• When using out, the variable being passed does not need to be initialized before being passed to the method.
• It also allows two-way communication between the method and the calling code, similar to ref.
• However, the method must assign a new value to the parameter inside the method before it returns. The variable passed in as out must be assigned a value inside the method, or it will result in a compilation error.

using System;

public class Program
{
    static void Main()
    {
        int x = 5;
        int y = 10;

        // Using ref keyword
        Console.WriteLine("Using ref keyword:");
        Console.WriteLine("Before method call: x = " + x);
        MultiplyByTwo(ref x);
        Console.WriteLine("After method call: x = " + x);
        Console.WriteLine();

        // Using out keyword
        Console.WriteLine("Using out keyword:");
        int result;
        MultiplyByThree(out y, out result);
        Console.WriteLine("After method call: y = " + y + ", result = " + result);
    }

    // Method that multiplies the parameter by two using ref keyword
    static void MultiplyByTwo(ref int number)
    {
        // The method doesn't have to assign a new value to 'number'
        // We can modify the existing value
        number *= 2;
        // The change made to 'number' is reflected in the calling code
    }

    // Method that multiplies the parameter by three using out keyword
    static void MultiplyByThree(out int number, out int result)
    {
        number = 3;
        result = number * 2;
       // Both 'number' and 'result' are assigned inside the method
    }
}

Output:

Using ref keyword:
Before method call: x = 5
After method call: x = 10

Using out keyword:
After method call: y = 3, result = 6

Note: In C#, the ref keyword returns the address of the variable rather than the value.

Example 2: ref keyword in C#

The following example demonstrates the use of the ref keyword to pass value-type parameters to a method.

using System;
namespace Ref
{
    class program
    {
        public static void Main()
        {
            // Calling method
            int number = 10; // Variable must be initialized.
            Console.WriteLine($"Previous value of the number = {number}");
            //Passing int number as ref parameter in the method
            PassByReference(ref number);
            Console.WriteLine($"Current value of the number = {number}");

            Console.ReadLine();
        }
        public static void PassByReference(ref int number)
        {
            //Called method
            number ++;
        }
    }
}

The result indicates that the modifications made to the “number” variable in the called method have been updated in the calling method as well.

Example: Out keyword in C#

using System;
namespace OutKeyword
{
    class program
    {
        public static void Main()
        {
            //Calling method

            int number; // Initialization is optional

            OutMethod(out number);

            Console.WriteLine($"number:{number} after passed to the called method");

            Console.ReadKey();
        }

        public static void OutMethod(out int number)
        { 
            //Called method
            number = 20;
        }
    }
}

Example 3: Passing multiple out parameters to a method.

The following is a simple example of using out parameters to return multiple values ​​of different data types.

using System;
namespace OutKeyword
{
    class program
    {
        public static void Main()
        {
            // Calling method       
            int id;  // Initialization is optional in case of out parameter
            string name;
            OutMethod(out id, out name);
            Console.WriteLine($"Id : {id} , Name = {name}");

            Console.ReadKey();
        }
        public static void OutMethod(out int id, out string name)
        {
            //Called method
            //Return multiple values using out parameters
            id = 52894;
            name = "Shekh Ali";
        }
    }
}

It is not possible to pass a property as a ref or out parameter, because properties are implemented as methods, not variables.

In C#, a method typically returns only one data type at a time. However, by using the out parameters, a method can return multiple values of different data types simultaneously.

C# ref vs out comparison

Here is a comparison of the ref and out keywords in C#:

When you pass a value type as a reference using ref or out, only a reference to the value is passed, so changes made to the value in the called function affect the original value in the calling code.

However, when you pass a value type by value, the actual value is passed, so changes made in the called function won’t affect the original value in the calling code.

Ref and out keywords in method overloading

In C#, you cannot use the ref and out keywords at the same time when overloading methods. This means you cannot have one version of a method that takes a ref parameter and another version that takes an out parameter.

Method overloading is possible in C# when one version of the method takes a ref argument and another version takes a normal argument. In this case, the method can be called with either a ref argument or a normal argument, depending on the needs of the calling code.

The following example is perfectly valid for the method overloading.

using System;
namespace MethodOverLoading
{
    class program
    {   
        public static void MyMethod(int a)
        {           
            a = 10;          
        }
        public static void MyMethod(out int b)
        {   
            //method signature must be different.      
            b = 10;
        }
    }
}

Summary:

In C#, the ref and out keywords are used to pass arguments as a reference to a method. If you use ref or out, any changes made to the argument inside the method will affect the original value outside the method.

When you know the value before calling the method, use ref. But when you don’t know the value before calling the method, use out.

FAQs

Here are some common questions about the ref and out keywords in C#:

Related post:  Value type and Reference type in C#

I hope this post was helpful. If you have any questions, please feel free to leave them in the comments section below.

Recommended Articles

• 10 Difference between interface and abstract class In C#
• C# Array vs List: When should you use an array or a List?
• C# Stack Class With Push And Pop Examples
• C# Static class
• C# Hashtable
• Top 50 C# Interview Questions And Answers
• ASP.NET Core Middleware With Examples
• WCF vs Web API
• IEnumerable Interface in C# with examples
• Constructors in C# with Examples
• C# Enum | How To Play With Enum in C#?
• Exception Handling in C#| Use of try, catch, and finally block
• Generic Delegates in C# With Examples
• C# Dictionary with Examples
• Multithreading in C#

• Author
• Recent Posts

Shekh Ali

Meet Shekh Ali, a skilled Software engineer and passionate blogger with an MCA degree and 8+ years of experience in the field. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Shekh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• CTE in SQL Server: Learn Common Table Expressions with Examples - September 14, 2023
• Garbage Collection in C#: Managing Memory Efficiently - September 13, 2023
• Static vs Singleton in C#: Understanding the Key Differences - September 6, 2023