Difference between Ref and Out keywords in C#

Last updated on December 31st, 2022 at 02:47 am

Here is the difference between Ref and Out keywords in C#:

The main difference between ref and out is that ref requires the argument to be initialized before it is passed to the called method, while out does not. ref keyword is generally used when the called method needs to both read and write the value of the argument, while out keyword is typically used when the called method only needs to write to the argument and the calling method is responsible for initializing it.

What is Ref Keyword in C#?

The ref keyword is used to pass an argument by reference. This means that the called method can modify the value of the argument and the changes will be reflected in the calling method. The argument must be initialized before it is passed to the called method.

• The ref keyword must be used in the declaration of both the calling method and the called method.
• The argument must be initialized before it is passed to the called method using the ref keyword.
• The called method can both read and write the value of the argument.
• The ref keyword allows parameters to be passed as references, meaning that any changes made to the variables within the called method will be reflected in the original variables in the calling method.

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

Example: 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 ++;
        }
    }
}

In the output shown above, it is clear that the modifications made to the variable number in the called method have been reflected in the calling method.

What is Out Keyword in C#?

The out keyword allows you to pass parameters to a method as reference types, regardless of whether they have been assigned a value or not. It functions similarly to the ref keyword. However, it is required that the value of a parameter be initialized in the called method before control is returned to the calling method.

• Normally, a method can only return a single value. However, the out keyword can be used to enable a method to return multiple values.
• If you want to pass a variable as an out parameter to a method, you do not need to initialize it before passing it as an out parameter.
• When using the out keyword, it is necessary to initialize the parameter within the called method.

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

Passing multiple out parameters.

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.

We know that in C #, a method can only return one data type at a time but using out parameters, a method can return multiple values ​​of different data types.

C# ref vs out comparison

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

When passing a value type as a reference (using either the ref or out keyword), there is no boxing of the value. Instead, only the reference to the value is passed. This is in contrast to passing by value, where the actual value of the variable is passed.

This means that when passing a value type as a reference, changes made to the value within the called function will be reflected in the calling code, whereas changes made to a value type passed by the value will not be reflected in the calling code.

Ref and out keywords in method overloading

In C#, it is not possible to use the ref and out keywords simultaneously in method overloading. Specifically, it is not possible to overload a method by having one version of the method take a ref parameter and another version take 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# both ref and out keywords are used to pass arguments as a reference within a method.
Any changes in the variable value inside the method will get reflected outside the calling method.

The ref should be used when the value is known before calling the method; out should be used when the value is unknown before calling the method.

FAQ

Here are some common questions about the ref and out keywords in C#, along with their answers:

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)

• SQL Server Indexing: Clustered vs Non Clustered Index Explained - March 26, 2023
• Mastering Database Normalization: Best Practices and Techniques - March 25, 2023
• CRM Databases: The Key to Enhanced Customer Engagement and Sales - March 23, 2023