ref, out, in and ref readonly parameters

Swap(a, b) with a at 1 and b at 2 swaps nothing: the method receives copies of 1 and 2 and swaps the copies. To change a caller’s variables, or to hand back more than one result, a parameter must refer to the caller’s variable itself, and C# has four modifiers for that: ref, out, in and ref readonly.

You will swap two variables with ref, hand back extra results with out, write a Try method like int.TryParse, and choose a modifier from a table of what each one allows.

A plain parameter gets a copy, and ref passes the variable itself

By default C# passes every argument by value: the parameter is a new variable that starts with a copy of the argument, so the method can change it without touching the caller. This is passing by valuepassing by value: Passing an argument as a copy: the parameter is a new variable that starts with the argument's value, so assigning to it never changes the caller's variable. C# passes every argument this way unless a modifier says otherwise.. A ref parameter is passed by referencepassing by reference: Passing the caller's variable itself, with ref, out, in or ref readonly: the parameter is another name for that variable, so the method works on it rather than on a copy.: it is another name for the caller’s variable, so whatever the method assigns to it, the caller sees. Both the method and the call write ref, and the variable must have a value before the call. Step through the two swaps:

// A plain parameter is a copy of the caller's value; a ref parameter is the caller's variable itself.
int a = 1, b = 2;
SwapCopies(a, b);
Console.WriteLine($"after SwapCopies: a = {a}, b = {b}");
Swap(ref a, ref b);
Console.WriteLine($"after Swap:       a = {a}, b = {b}");

int[] seats = [7, 9];
Swap(ref seats[0], ref seats[1]); // array elements are variables too
Console.WriteLine($"seats after Swap: {seats[0]}, {seats[1]}");

static void SwapCopies(int x, int y)
{
    (x, y) = (y, x); // swaps the two copies, and nothing else
}

static void Swap(ref int x, ref int y)
{
    (x, y) = (y, x);
}

after SwapCopies: a = 1, b = 2
after Swap:       a = 2, b = 1
seats after Swap: 9, 7

SwapCopies swapped its own x and y and left a and b as they were. Swap(ref a, ref b) made x another name for a and y for b, so the same swap changed the caller’s variables. Array elements are variables too, which is why Swap(ref seats[0], ref seats[1]) swapped the two seats. A property is not a variable, so it cannot be passed with ref.

out hands back an extra result, and the Try pattern is built on it

An out parameter is passed by reference as well, but its value flows the other way: the caller need not give it a value, and the method must assign it before it returns. The call can declare the variable on the spot, out int number, or throw the result away with out _. Every TryParse method in .NET has one:

// out hands back an extra result. A Try method returns whether it worked, and the value through out.
foreach (string text in new[] { "42", "4x2", "", "2147483648" })
{
    bool ok = int.TryParse(text, out int number);
    Console.WriteLine($"int.TryParse(\"{text}\"): {ok}, number = {number}");
}

if (TryParseQuantity("12 kg", out int quantity, out string unit))
{
    Console.WriteLine($"TryParseQuantity(\"12 kg\"): {quantity} and {unit}");
}
Console.WriteLine($"TryParseQuantity(\"kg\"): {TryParseQuantity("kg", out _, out _)}");

static bool TryParseQuantity(string text, out int quantity, out string unit)
{
    string[] parts = text.Split(' ', 2);
    if (parts.Length == 2 && int.TryParse(parts[0], out quantity))
    {
        unit = parts[1];
        return true;
    }
    quantity = 0;
    unit = "";
    return false;
}

int.TryParse("42"): True, number = 42
int.TryParse("4x2"): False, number = 0
int.TryParse(""): False, number = 0
int.TryParse("2147483648"): False, number = 0
TryParseQuantity("12 kg"): 12 and kg
TryParseQuantity("kg"): False

int.TryParse returned true and 42 for “42”, and false with number set to 0 for the other three: “4x2” is not a number, the empty string has no digits, and 2147483648 is one more than int.MaxValue. This is the Try patternTry pattern: A method named TrySomething that returns true or false for success and hands back its result through an out parameter, such as int.TryParse, beside a method that throws for bad input. of Microsoft’s design guidelines: the name starts with Try, the method returns bool for success and hands back the value through out, and a method that throws exists beside it for callers that expect valid input. TryParseQuantity follows the pattern with two out parameters and assigns both on every path, because the compiler refuses a method that could return without assigning one of them.

in and ref readonly pass a variable for reading only

In parameters and ref readonly parameters pass by reference too, but the method may only read the variable. They exist for structs, whose every byte a copy moves, while a reference is 8 bytes on a 64-bit process. With in the call may leave the modifier out, and a constant is passed through a hidden copy. With ref readonly, new in C# 12, the call writes in or ref, and the compiler warns when it writes neither.

Passing a large struct with in avoids copying it, but calling a method that may change the struct on an in parameter makes the compiler copy it anyway. Async methods and iterators cannot have ref, out or in parameters at all, so an async method returns its extra results in a tuple or a record instead. C# 14 lets a lambda’s parameters carry these modifiers without their types.

in and ref readonly with structs: hidden copies shown, and when they pay Pro: opens with a Pro, Premium or Ultimate pass

The errors that ref, out and in cause, reproduced and fixed Pro: opens with a Pro, Premium or Ultimate pass

Designing Try methods, and C# 14 lambdas with out parameters Pro: opens with a Pro, Premium or Ultimate pass

Practise: check the format of an IFSC

ifsc.cs starts with a method that throws, so all eight of its checks fail:

// Practice: write TryParseIfsc, then run this file until all eight checks pass. An IFSC has 11 characters: 4 letters
// for the bank, a fifth character that is always 0 (zero), and 6 letters or digits for the branch. Accept lower case,
// return both parts in capitals, and set both outs to "" when the input is not an IFSC. This checks the format only.
(string? Input, bool Ok, string Bank, string Branch)[] checks =
[
    ("SBIN0001234", true, "SBIN", "001234"),
    ("HDFC0ABC123", true, "HDFC", "ABC123"),
    ("icic0004321", true, "ICIC", "004321"),
    ("SBIN1001234", false, "", ""),
    ("SBIN000123", false, "", ""),
    ("SB1N0001234", false, "", ""),
    ("SBIN00012$4", false, "", ""),
    (null, false, "", ""),
];

int passed = 0;
foreach (var (input, ok, bank, branch) in checks)
{
    string shown = input is null ? "null" : $"\"{input}\"";
    string verdict;
    try
    {
        bool got = TryParseIfsc(input, out string gotBank, out string gotBranch);
        verdict = got == ok && gotBank == bank && gotBranch == branch
            ? "ok"
            : $"FAIL, returned {got} with \"{gotBank}\" and \"{gotBranch}\"";
    }
    catch (Exception e)
    {
        verdict = $"FAIL, {e.GetType().Name}";
    }
    if (verdict == "ok")
    {
        passed++;
    }
    Console.WriteLine($"TryParseIfsc({shown}): {verdict}");
}
Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

static bool TryParseIfsc(string? input, out string bank, out string branch)
{
    throw new NotImplementedException("Check the length and each part, then assign bank and branch.");
}

TryParseIfsc("SBIN0001234"): FAIL, NotImplementedException
TryParseIfsc("HDFC0ABC123"): FAIL, NotImplementedException
TryParseIfsc("icic0004321"): FAIL, NotImplementedException
TryParseIfsc("SBIN1001234"): FAIL, NotImplementedException
TryParseIfsc("SBIN000123"): FAIL, NotImplementedException
TryParseIfsc("SB1N0001234"): FAIL, NotImplementedException
TryParseIfsc("SBIN00012$4"): FAIL, NotImplementedException
TryParseIfsc(null): FAIL, NotImplementedException
0 of 8 checks pass

Write TryParseIfsc, run dotnet run ifsc.cs until it prints 8 of 8 checks pass, then try the questions below:

Interview questions

Fresher · What is the difference between ref and out parameters in C#?

Both pass a variable by reference, so the method works on the caller’s variable, not on a copy, and both must be written at the call as well as in the method. They differ in which way the value flows. A ref argument must already have a value, and the method may read it and may change it, as Swap(ref a, ref b) does. An out argument need not have a value, and the method must assign it before it returns, or the build fails; the call can declare it on the spot, out int number. Use ref when a method updates an existing value, and out when it produces an extra result, as Try methods do.

Key takeaways

• Arguments are passed by value unless a modifier says otherwise, so a method changes only its own copy.
• ref makes a parameter another name for the caller’s variable, which must have a value first; the call writes ref too.
• An out parameter makes the method assign the variable before it returns, which is what the Try pattern uses to hand back a value beside a bool.
• In parameters and ref readonly parameters pass a variable by reference for reading only, which can save copying a large struct.