Parameters

Parameters are how a method gets what it needs. The behaviour that catches almost everyone is what happens when the thing you pass is an object.

The rule in C# is one sentence: arguments are copied. Everything else follows from what exactly gets copied.

int stock = 10;

Reduce(stock, 3);
Console.WriteLine(stock);   // still 10

static void Reduce(int quantity, int amount)
{
    quantity -= amount;     // changes the copy and nothing else
}

• quantity is a copy of stock. Subtracting from it cannot reach back to the caller's variable.
• This surprises people because the method looks like it is doing something. It is — to a value that disappears when the method ends.
• To give the caller the new quantity, return it: stock = Reduce(stock, 3);

var order = new Order { Reference = "ORD-1041", Status = "Draft" };

Mutate(order);
Console.WriteLine(order.Status);      // Submitted — the caller sees this

Replace(order);
Console.WriteLine(order.Reference);   // ORD-1041 — the caller does not see this

static void Mutate(Order order)
{
    order.Status = "Submitted";
}

static void Replace(Order order)
{
    order = new Order { Reference = "ORD-9999", Status = "Draft" };
}

public class Order
{
    public string Reference { get; set; } = "";
    public string Status { get; set; } = "";
}

• Both methods take the same kind of parameter. Mutate changes the object the reference points at, and the caller sees it, because there is only one object.
• Replace assigns a new object to its parameter. That parameter is a copy of the reference, so the caller's variable still points where it always did, and the new order is discarded when the method ends.
• This is what "reference types are passed by value" means: the reference is copied, the object is shared.
• When a method should give the caller a different object, return it. That is clearer than any keyword, and the call site shows it.

decimal balance = 250m;
ApplyFee(ref balance, 4.99m);
Console.WriteLine(balance);                 // 245.01

if (TryGetDiscountRate("SPRING24", out decimal rate))
{
    Console.WriteLine($"Rate: {rate:P0}");
}

Console.WriteLine(Total(19.99m, 4.50m, 120m));   // 144.49

static void ApplyFee(ref decimal balance, decimal fee)
{
    balance -= fee;
}

static bool TryGetDiscountRate(string code, out decimal rate)
{
    rate = 0m;                    // assigned on every path, including failure

    if (code != "SPRING24")
    {
        return false;
    }

    rate = 0.10m;
    return true;
}

static decimal Total(params decimal[] amounts)
{
    decimal total = 0m;

    foreach (decimal amount in amounts)
    {
        total += amount;
    }

    return total;
}

• ref has to be written at the call site too. C# insists on that so a reader can see which arguments a call might change.
• An out parameter must be assigned on every path out of the method, failure included, or the build fails. Setting it first is the simplest way to satisfy that.
• The Try pattern pairs a bool with an out value: one answer for whether it worked, one for the result.
• params lets the caller pass three numbers rather than construct an array. Inside the method it is an ordinary array.