out Parameter In C#

using System;  
using static System.Console;  
  
namespace OutExample  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            WriteLine("Please enter radious for circle");  
            double radious = Convert.ToDouble(ReadLine());  
            double circumference = CalculateCircle(radious, out double area);  
            WriteLine($"Circle's circumference is {circumference}");  
            WriteLine($"Circle's Area is {area}");  
            ReadKey();  
        }  
  
       static double CalculateCircle(double radious, out double area)  
        {  
            area = Math.PI * Math.Pow(radious, 2);  
            double circumference = 2 * Math.PI * radious;  
            return circumference;  
        }  
    }  
}

As shown in the example, the Out parameter is declared with specifying type in the parameter list for clarity. However, the language does support using an implicitly typed local variable. The data type of a var variable will be determined when assigning a value to the variable. After assigning the variable value, the variable has a defined data type and cannot be replaced.

As var type variable has local scope (means scope in the method body), similarly, in-line Out parameter has scope in method body that’s why var type can also be used as Out parameter.

Let’s create an example. Find the length of the longest subarray which contains numbers that can be arranged in a continuous sequence from an integer array.

using static System.Console;  
  
namespace OutExample  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            int [] arr = { 1, 56, 58, 57, 90, 92, 94, 93, 91, 45 };  
            int n = arr.Length;  
            findLength(arr, n, out var maxlenth);  
            WriteLine($"Length of the longest contiguous subarray is {maxlenth}");             
            ReadKey();  
        }  
  
        static void findLength(int []arr,  int n, out int maxlength)  
        {  
            maxlength = 1;    
            for (int i = 0; i < n - 1; i++)  
            {                  
                int mn = arr[i], mx = arr[i];                  
                for (int j = i + 1; j < n; j++)  
                {                     
                    mn = min(mn, arr[j]);  
                    mx = max(mx, arr[j]);                      
                    if ((mx - mn) == j - i)  
                    {  
                        maxlength = max(maxlength, mx - mn + 1);  
                    }                          
                }  
            }             
        }  
        static int min(int x, int y)  
        {  
            return (x < y) ? x : y;  
        }  
        static int max(int x, int y)  
        {  
            return (x > y) ? x : y;  
        }  
    }  
}

Now, run this program. The result shows as per the following figure.

Figure 2: Output

As shown in the above program, the out parameter can be an implicit type.

Use in Try Pattern

The Out parameter is mostly used in the Try-pattern. In this pattern, a method returns a bool indicating success or failure and an Out variable that provides the result if the method succeeds. Let’s see an example for same. This example shows that user enters value. If the value is valid integer, then it shows result.

using static System.Console;  
  
namespace OutExample  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            WriteLine("Please enter you age");  
            bool isValid = int.TryParse(ReadLine(), out int age);  
            string message = isValid ? $"You are {age} Years old" : "Please enter valid age";  
            WriteLine(message);             
            ReadKey();  
        }         
    }  
}

As shown in above code, try pattern method assigns value in Out parameter if it succeeded. Now, run this program and the result shows as per the following figure.

Figure 3: Output

Conclusion

The Out parameter features are improved in C# 7.0. Both in-line and implicit type declaration are new in this new version.