Ref, Out and In — Passing by Reference

By default, method parameters are passed by value — the method receives a copy of the value (for value types) or a copy of the reference (for reference types). C# provides three parameter modifiers that change this behaviour: ref passes the variable itself by reference, out requires the method to assign the variable before returning, and in passes a read-only reference to avoid copying large structs. These modifiers appear in TryParse patterns, in high-performance code, and occasionally in utility methods — but they should be used sparingly, as returning a tuple is often cleaner.

Ref — Read and Write the Caller’s Variable #

// ref — the method can READ and WRITE the caller's original variable
public void Increment(ref int counter)
{
    counter++;   // modifies the caller's variable
}

int score = 10;
Increment(ref score);    // caller must use the ref keyword too
Console.WriteLine(score);   // 11

// Classic use: swap two values
public static void Swap<T>(ref T a, ref T b)
{
    T temp = a;
    a = b;
    b = temp;
}

int x = 5, y = 10;
Swap(ref x, ref y);
Console.WriteLine($"x={x}, y={y}");   // x=10, y=5

Out — The Method Must Assign It #

// out — method MUST assign before returning; caller does NOT need to initialise
public bool TryDivide(int dividend, int divisor, out double result)
{
    if (divisor == 0)
    {
        result = 0;     // must assign even when returning false
        return false;
    }
    result = (double)dividend / divisor;
    return true;
}

// Inline declaration (C# 7+)
if (TryDivide(10, 2, out double quotient))
    Console.WriteLine($"Result: {quotient}");   // Result: 5

// Discard the out parameter when you don't need it
if (int.TryParse("42", out _))   // _ discards the parsed value
    Console.WriteLine("Valid integer");

// The Try* pattern throughout .NET BCL
int.TryParse("123",                out int n);
double.TryParse("3.14",            out double d);
DateTime.TryParse("2025-06-15",    out DateTime dt);
Guid.TryParse("abc-123",           out Guid g);

In — Read-Only Reference (Performance) #

// in — passes a read-only reference; method cannot modify the variable
// Used to avoid copying large value types (structs) for performance
public static double CalculateDistance(in Vector3D a, in Vector3D b)
{
    double dx = a.X - b.X;
    double dy = a.Y - b.Y;
    double dz = a.Z - b.Z;
    return Math.Sqrt(dx*dx + dy*dy + dz*dz);
    // a and b cannot be reassigned inside this method
}

readonly struct Vector3D(double X, double Y, double Z)
{
    public double X { get; } = X;
    public double Y { get; } = Y;
    public double Z { get; } = Z;
}

var p1 = new Vector3D(0, 0, 0);
var p2 = new Vector3D(3, 4, 0);
double dist = CalculateDistance(in p1, in p2);  // 5.0 (3-4-5 triangle)

Comparison of Parameter Modifiers #

Common Mistakes #

Mistake 1 — Using ref/out in async methods (compile error) #

❌ Wrong — cannot use ref or out parameters in async methods:

public async Task ProcessAsync(ref int count)   // compile error!

✅ Correct — return a tuple from async methods instead of using out/ref.

Mistake 2 — Forgetting to assign out parameter in all code paths #

❌ Wrong — compile error: out parameter not assigned if divisor != 0 branch not reached:

public bool TryDivide(int a, int b, out double result)
{
    if (b == 0) return false;  // forgot to assign result before returning!
    result = (double)a / b;
    return true;
}

✅ Correct — assign out parameter in every code path before returning:

if (b == 0) { result = 0; return false; }   // ✓ assigned before return