The Variation Between C#’s ref, out, and in Parameters

In C#, parameters are supplied by value by default when a method is called. This indicates that the variable is copied into the method, and that modifications made within the method have no effect on the original variable outside of it. Sometimes you want the original variable to be used directly by the method. The ref, out, and in parameters are useful in this situation. With this, variables can be passed by reference, which means that the caller and the method share the same memory location.

C# ref Parameter – Pass by Reference with Read/Write Access

The ref keyword lets you pass a variable by reference, allowing the method to read and modify its value. The variable must be initialized before being passed.

A real-world example could be a bank interest calculation. The method takes the current balance and updates it after applying interest.

using System;

public class Bank
{
    public void ApplyInterest(ref decimal balance, decimal interestRate)
    {
        balance += balance * interestRate / 100;
        Console.WriteLine($"Balance after applying interest: {balance}");
    }
}

public class Program
{
    public static void Main()
    {
        decimal accountBalance = 1000m;
        Bank bank = new Bank();

        Console.WriteLine($"Initial Balance: {accountBalance}");
        bank.ApplyInterest(ref accountBalance, 5);
        Console.WriteLine($"Final Balance: {accountBalance}");
    }
}

The advantage of ref is that the method can modify the variable without needing to return it.

The disadvantage is that changes may happen unexpectedly, and the variable must be initialized before passing.

C# out Parameter – Pass by Reference for Output Only

The out keyword is used when a method will set the value of a variable before it returns. The variable does not need to be initialized beforehand.

This is often useful when returning multiple values. For example, a login method could return both a success flag and the user’s role.

using System;

public class AuthService
{
    public bool Login(string username, string password, out string role)
    {
        if (username == "admin" && password == "1234")
        {
            role = "Administrator";
            return true;
        }
        else if (username == "john" && password == "pass")
        {
            role = "User";
            return true;
        }
        else
        {
            role = "Guest";
            return false;
        }
    }
}

public class Program
{
    public static void Main()
    {
        AuthService auth = new AuthService();

        if (auth.Login("admin", "1234", out string userRole))
        {
            Console.WriteLine($"Login successful! Role: {userRole}");
        }
        else
        {
            Console.WriteLine("Login failed.");
        }
    }
}

The benefit of out is that it allows multiple return values.

The downside is that the method must always assign a value to it, which can sometimes make code harder to maintain.

C# in Parameter – Pass by Reference with Read-Only Access

The in keyword passes a variable by reference but makes it read-only inside the method. This ensures that the value cannot be modified.

It’s helpful for large structs where copying would be expensive. For example, calculating the distance between two coordinates.

using System;

public struct Coordinates
{
    public double X { get; }
    public double Y { get; }

    public Coordinates(double x, double y)
    {
        X = x;
        Y = y;
    }
}

public class GeoService
{
    public double CalculateDistance(in Coordinates point1, in Coordinates point2)
    {
        double dx = point2.X - point1.X;
        double dy = point2.Y - point1.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

public class Program
{
    public static void Main()
    {
        Coordinates location1 = new Coordinates(0, 0);
        Coordinates location2 = new Coordinates(3, 4);

        GeoService geo = new GeoService();
        double distance = geo.CalculateDistance(in location1, in location2);

        Console.WriteLine($"Distance: {distance}");
    }
}

The main advantage is performance and safety.

The drawback is that it is most useful for large data types and provides little benefit for small ones.

Conclusion

While ref, out, and in all pass variables by reference; they serve different purposes. ref is for read/write, out is for output-only, and in is read-only. Use them wisely, as overuse can make your code harder to read and debug. They are powerful tools in C# when used in the right scenarios.

ASP.NET Core 10.0 Hosting Recommendation

HostForLIFE.eu
HostForLIFE.eu is a popular recommendation that offers various hosting choices. Starting from shared hosting to dedicated servers, you will find options fit for beginners and popular websites. It offers various hosting choices if you want to scale up. Also, you get flexible billing plans where you can choose to purchase a subscription even for one or six months.