ref, out and params

Arguments are copied by default

When you call a method, each argument is copied into the parameter. The method works on its copy, so the caller's variable is safe:

void Double(int n)
{
    n = n * 2;                 // changes the copy only
}
 
int x = 5;
Double(x);
Console.WriteLine(x);          // 5

This is called pass by value, and it's what you want most of the time: methods that return results instead of secretly changing your variables are easier to understand.

ref: let the method change the caller's variable

Sometimes a method really should modify the caller's variable. Mark the parameter — and the argument — with ref:

void Double(ref int n)
{
    n = n * 2;
}
 
int x = 5;
Double(ref x);
Console.WriteLine(x);          // 10

Now n isn't a copy; it's another name for x itself. The ref at the call site is mandatory, so readers can see that x might change.

The classic use is swapping:

void Swap(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

out: return more than one value

A method has one return value. out parameters let it hand back extra results:

void MinMax(int[] numbers, out int min, out int max)
{
    min = numbers.Min();
    max = numbers.Max();
}
 
MinMax(new[] { 4, 1, 9 }, out int lo, out int hi);   // declare the variables inline
Console.WriteLine($"{lo}..{hi}");                    // 1..9

The compiler insists that every out parameter is assigned before the method returns.

The Try pattern

You've already met the most important use of out: methods named TryXxx that return true/false for success and put the result in an out parameter — no exceptions for expected failures.

if (int.TryParse(input, out int age))
{
    Console.WriteLine($"Next year you'll be {age + 1}");
}
else
{
    Console.WriteLine("That's not a number");
}
 
// Discard an out value you don't need with _
bool isNumber = int.TryParse(input, out _);

Dictionary.TryGetValue (Track 3) follows the same pattern, and you can write your own.

params: any number of arguments

params lets callers pass a list of values without building an array themselves:

int Sum(params int[] numbers)
{
    int total = 0;
    foreach (int n in numbers) total += n;
    return total;
}
 
Sum();                 // 0 — numbers is an empty array
Sum(5);                // 5
Sum(1, 2, 3, 4);       // 10
Sum(new[] { 1, 2 });   // an array works too

params must be the last parameter. You use it all the time without noticing: Console.WriteLine("{0} + {1}", a, b) and string.Join(", ", a, b, c) are params methods.

Try it

Key takeaways

• Arguments are copied by default — the method can't change the caller's variables.
• ref passes the variable itself; required at both declaration and call site.
• out parameters are extra outputs; the Try pattern uses them to avoid exceptions.
• params accepts any number of arguments as an array.