How are arguments passed to methods in C#? Explain pass-by-value for value and reference types, ref, out, in, ref readonly, params, and optional and named parameters.

1. What the IL looks like

void A(int x)          -> parameter type int32
void B(ref int x)      -> parameter type int32&           (managed pointer)
void C(out int x)      -> int32& + [Out] attribute
void D(in int x)       -> int32& + modreq(InAttribute) + [IsReadOnly]
void E(ref readonly int x) -> int32& + [RequiresLocation] + [IsReadOnly]

At the CLR level ref, out, in and ref readonly are all the same thing: a managed pointer (T&) to the caller's storage. The differences are compiler-enforced rules encoded as attributes. That is why you cannot overload M(ref int) and M(out int) — the CLR signatures are identical.

A managed pointer can point into the stack, into the middle of a heap object (a field or array element), or into unmanaged memory. The GC understands these interior pointers and updates them when it moves objects. Because a managed pointer can point to the stack, it must never outlive the frame — which is the reason for the ref safety rules and why refs cannot be stored in heap fields or captured by lambdas.

2. Value-type copies and the cost model

Passing a struct by value copies all its bytes. Rough guidance:

• Up to ~16 bytes (two registers on x64): passing by value is usually cheapest — values travel in registers.
• Larger structs are copied to the stack for each call; at 64–128+ bytes in hot loops, in/ref readonly with a readonly struct wins.
• Passing by reference has its own cost: every field access becomes an indirection, and the JIT may be less able to keep fields in registers. Always benchmark.

3. Defensive copies explained

public struct Counter { public int Value; public void Increment() => Value++; }

void Use(in Counter c)
{
    c.Increment();   // compiles! but mutates a hidden COPY
    Console.WriteLine(c.Value); // original unchanged
}

The compiler must guarantee c is not modified through an in parameter. For a non-readonly struct it cannot know whether Increment mutates, so it copies c to a temp and calls the method on the temp. This silently costs a copy per member call and hides bugs. Marking the struct readonly (or the member readonly) removes the copy and makes mutation a compile error.

4. out and definite assignment

out flips definite-assignment responsibility:

• In the callee, the parameter starts unassigned; reading it before assigning is CS0269, and returning without assigning is CS0177.
• In the caller, the variable is definitely assigned after the call, which is why if (dict.TryGetValue(k, out var v)) Use(v); works.
• out var _ (discard) ignores a value without declaring a variable.

The Try-pattern returns bool for the expected failure case and uses out for the result. With nullable annotations, [NotNullWhen(true)] out T? value tells the compiler the value is non-null when the method returns true.

5. How params works, old and new

Classic params T[]:

Log("a", "b");   // compiled as Log(new[] { "a", "b" })
Log();           // compiled as Log(Array.Empty<string>())
Log(null);       // passes a null array, not an array containing null!

C# 13 params ReadOnlySpan<T>:

static int Sum(params ReadOnlySpan<int> values) { ... }
Sum(1, 2, 3);  // compiler uses an InlineArray on the stack - zero allocations

Overload resolution prefers the span overload over the array overload when both exist, which is how the BCL made string.Concat, Path.Combine and similar calls allocation-free in .NET 9 without source changes.

6. Optional parameters and binary compatibility

The default value is stored as metadata on the parameter (.param [n] = int32(3)) and the caller's compiler reads it and emits the constant at the call site. Consequences:

• Changing a default is a binary breaking change for callers that are not recompiled.
• Adding a new optional parameter to an existing public method is also binary breaking: the method signature changes, and old binaries throw MissingMethodException. Add an overload instead.
• Reflection and dynamic callers see the default through ParameterInfo.DefaultValue.

7. Overload resolution with ref kinds, params and optionals

• M(int) and M(ref int) can coexist (different ref-kind), but ref/out/in among themselves cannot.
• The compiler prefers, in order: an exact match without expansion, then a match that needs no optional-parameter filling, then params expanded form.
• Named arguments can make a call ambiguous or select a different overload than positional arguments would — keep public overload sets small and distinct.

Try it yourself

1. Write a non-readonly struct with a mutating method, pass it by in, call the method, and print the field.
2. Benchmark passing a 128-byte struct by value vs in with BenchmarkDotNet.
3. In SharpLab, compare the IL for a params int[] call and a params ReadOnlySpan<int> call.
4. Change a library's optional default and run an un-rebuilt consumer to see the old value used.

namespace Basics;

public readonly record struct Quote(decimal Price, decimal Fx, decimal Margin, decimal Tax);

public static class Parameters
{
    public static void Main()
    {
        // Reference copied by value
        var items = new List<int> { 1, 2, 3 };
        Reset(items);
        Console.WriteLine(items.Count);           // 0: Clear() hit the caller's list, new() did not

        // ref
        int a = 1, b = 2;
        Swap(ref a, ref b);
        Console.WriteLine($"{a} {b}");             // 2 1

        // out + discard
        if (TryParseAge("42", out var age)) Console.WriteLine(age);
        _ = TryParseAge("oops", out _);

        // in with a readonly struct: no copies
        var q = new Quote(100m, 1.5m, 0.1m, 0.1m);
        Console.WriteLine(Total(in q));

        // params collections (C# 13): no array allocation
        Console.WriteLine(Sum(1, 2, 3, 4));

        // named + optional arguments
        Send("[email protected]", urgent: true);
    }

    private static void Reset(List<int> list)
    {
        list.Clear();       // visible to caller
        list = new() { 99 }; // only changes the local copy of the reference
    }

    private static void Swap(ref int x, ref int y) => (x, y) = (y, x);

    private static bool TryParseAge(string text, out int age)
        => int.TryParse(text, out age) && age is >= 0 and <= 150;

    private static decimal Total(in Quote q) => q.Price * q.Fx * (1 + q.Margin) * (1 + q.Tax);

    private static int Sum(params ReadOnlySpan<int> values)
    {
        int total = 0;
        foreach (var v in values) total += v;
        return total;
    }

    private static void Send(string to, int retries = 3, bool urgent = false)
        => Console.WriteLine($"to={to} retries={retries} urgent={urgent}");
}