Difference Between Ref and Out Keywords

Pratibha Yadav

1y919C#

What is the purpose of using ref or out in C# and what is the difference?

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Onkar Sharma1y ago
Accepted answer
The ref and out keywords in C# are often confusing for beginners and experienced alike, but they serve different purposes. Now, let's look at the quick difference between ref and out keywords in C#.

Ref Keyword in C#

The ref keyword in C# is used to pass arguments by reference. In simple words, any changes made to this argument in the method will be reflected in that variable when the control returns back to the calling method.

Key Points
- An argument for a ref parameter must include the ref modifier/keyword.
- Data can pass bi-directionally when the ref keyword is used.
- Ref means the method can read or write the value of the argument.
- Properties cannot be arguments to ref parameters since they are variables, not methods.
Examples

The example given below demonstrates the functionality of Ref Keyword in C#. Let's see.
```
namespace RefVsOutInCsharp.RefKeyword
{
    internal class RefInCsharp
    {
        static void Main(string[] args)
        {
            int originalValue = 10;
            Console.WriteLine("-- Example of Ref Keyword In C# --");
            Console.WriteLine("Original Ref value: " + originalValue);
            DoubleValue(ref originalValue);
            Console.WriteLine("New Ref value: " + originalValue);

            Console.ReadLine();
        }

        static void DoubleValue(ref int value)
        {
            value *= 2;
        }
    }
}
```
Out Keyword in C#

Out keyword in C# is used to pass arguments by reference. Declaring parameters for out method is useful when multiple values need to be returned from the method.

Key Points
- An argument for an out parameter must include the out modifier/keyword.
- Out means the method sets the value of the argument.
- When out keyword is used, then data is passed in a unidirectional way only.
- Properties cannot be arguments to out parameters since they are variables, not methods.
Examples

The example given below demonstrates the functionality of Out Keyword in C#. Let's see.
```
namespace RefVsOutInCsharp.OutKeyword
{
    internal class OutInCsharp
    {
        static void Main(string[] args)
        {
            int area, perimeter;

            CalculateDimensions(100, 200, out area, out perimeter);
            Console.WriteLine("-- Example of Out Keyword In C# --");
            Console.WriteLine("Area: " + area);
            Console.WriteLine("Perimeter: " + perimeter);

            Console.ReadLine();
        }

        static void CalculateDimensions(int width, int height, out int area, out int perimeter)
        {
            area = width * height;
            perimeter = 2 * (width + height);
        }
    }
}
```
To know more about the detailed difference between ref and out keyword in C#. visit:
- https://www.c-sharpcorner.com/blogs/difference-between-ref-and-out-keyword-in-c-sharp
Thanks!!
+3

Sangeetha S1y ago

The ref keyword is used to pass arguments by reference to a method or function, rather than passing them by value

public static string func(ref int num)  
{  
    string returnString = "Next-" + num.ToString();  
    num += 1;  
    return returnString;  
}  
static void Main(string[] args)  
{  
    int q = 1;  
    Console.WriteLine("The Previous value of integer 'q' is:" + q.ToString());  
    string test = func(ref q);  
    Console.WriteLine("The Current value of integer 'q' is:" + q.ToString());  
}

C#, methods that define output parameters utilize the out keyword. It offers a method to return multiple values

public static string method(out int q)  
{  
    q = 2;  
    string return_Text = "Next-" + q.ToString();  
    return return_Text;  
}  
static void Main(string[] args)  
{  
    int j = 1;  
    Console.WriteLine("The Previous value of integer j:" + j.ToString());  
    string str = method(out j);  
    Console.WriteLine("The Current value of integer j:" + j.ToString());  
}

Leo Qiao1y ago
1.Output parameter is one of ref variable. Reference variable is binding to value or instance, it is an alias of another variable.Because they are binding, no any copy or assignment between passing.
2.Reference parameter is considered as initially assigned, because it is alias of argument. It is argument.
3.Output parameter is not initially assigned, you have to assign a value to it in the function body.
4.Reference parameter is used to change a variable by calling a function. Output parameter is used to create a new instance for a variable.
+1
sasikala s1y ago
In C#, both ref and out are keywords used to pass arguments to methods by reference, allowing the method to modify the value of the arguments. However, they are used in slightly different ways. Here’s a breakdown of their purposes and differences:

ref
- Purpose: The ref keyword allows a method to read and modify the value of a variable passed to it.
- Initialization Requirement: The variable passed to a method using ref must be initialized before it is passed.
- Usage: Typically used when you want to return multiple values from a method, or when a method needs to modify the value of a variable.
Example:
```
public void UpdateValue(ref int number)
{
    number += 10; \/\/ Modifies the original variable
}

int myNumber = 5;
UpdateValue(ref myNumber); \/\/ myNumber becomes 15
```
out
- Purpose: The out keyword is used to indicate that a method will output a value, and it allows the method to initialize the variable.
- Initialization Requirement: The variable does not need to be initialized before being passed to the method, but it must be assigned a value before the method returns.
- Usage: Commonly used for methods that need to return multiple values or when a method might not return a value but still needs to output some information.
Example:
```
public void GetValues(out int number)
{
    number = 42; \/\/ Must initialize the variable before returning
}

GetValues(out int myNumber); \/\/ myNumber is now 42
```
Key Differences
1. Initialization:
  
  ref: The variable must be initialized before being passed.
  
  out: The variable does not need to be initialized before being passed.
2. Purpose:
  
  ref: Used when you want to both read and modify the value.
  
  out: Used when you only want to output a value and do not need to read its initial value.
3. Method Behavior:
  
  With ref, the caller's variable can be both read and modified.
  
  With out, the called method is required to assign a value before returning.
+2