Difference between Ref and Out keywords in C#

Last updated on January 25th, 2024 at 10:22 am

Here is an article that explains the difference between ref and out keywords in C# with multiple code examples.

In C#, ref and out are two keywords used to pass arguments to methods by reference. Although they are similar in many ways, there are some key differences between them.
Let’s explore the differences between ref and out keywords with multiple code examples.

Differences between ref and out keywords

Here are some key differences between ref and out keywords:

• The ref keyword is used to pass arguments to methods by reference. The out keyword is used to pass arguments to methods by reference when the method returns multiple values.
• 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.
• When you pass an argument by ref, any changes made to the argument inside the method are reflected in the original variable when the method returns. When you pass an argument by out, the method can modify the argument and return a value through it.
• It is necessary to initialize the value of a parameter before returning to the calling method when using the out keyword. It is not necessary to initialize the value of a parameter before returning to the calling method when using the ref keyword.

What is the ref keyword?

The ref keyword is used to pass arguments to methods by reference. When you pass an argument by reference, any changes made to the argument inside the method will be reflected in the original variable when the method returns.

The variable must be initialized before being passed with ref to the method.

Example: Ref keyword

Here is an example code snippet that demonstrates the use of the ref keyword:

using System;
namespace Ref
{
    class program
    {
        public static void Main()
        {
            // Initializing a variable 'number' with the value 10
            int number = 10;

            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)
        {
           // Incrementing the value of the referenced parameter by 1
            number ++;
        }
    }
}

Output:

Previous value of the number = 10
Current value of the number = 11

Code Explanation:

In the above example, we have defined a method called PassByReference that takes an integer argument by reference using the ref keyword. Inside the method, we increment the value of the argument by one. When we call the method with the ref keyword, the original variable is passed to the method by reference.
Therefore, any changes made to the argument inside the method are reflected in the original variable when the method returns.

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

What is the out keyword?

The out keyword is also used to pass arguments to methods by reference. However, it is generally used when a method returns multiple values. When you pass an argument by out, the method can modify the argument and return a value through it.

Important Points about out keyword:

• 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.

Example: Out keyword in C#

using System;

class OutKeywordExample
{
    // A method that initializes two out parameters
    public static void GetValues(out int first, out int second)
    {
        // Assigning values to the out parameters
        first = 10;
        second = 20;
    }

    // Main entry point of the program
    public static void Main()
    {
        int value1, value2;

        // Calling the method GetValues and passing variables as out parameters
        GetValues(out value1, out value2);

        // Displaying the values of the out parameters
        Console.WriteLine($"Value1: {value1}"); // Output: 10
        Console.WriteLine($"Value2: {value2}"); // Output: 20
    }
}

Output:

Value1: 10
Value2: 20

Example 2: 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

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#
• C# Tutorial
• C# Programs asked in interviews

• 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# 12 New Features in 2025: What’s New with .NET 8 - April 11, 2025
• Difference Between WCF and Web API with Examples: A Comprehensive Guide - March 27, 2025
• PUT vs PATCH vs POST in REST API: Key Differences Explained With Examples - March 23, 2025