The Default – Passing by Value

First, it's essential to understand the default behavior in C#. When you pass an argument to a method, you are typically passing by value. This applies to simple data types like int, double, bool, and structs.

"Passing by value" means the method receives a copy of the data. Any changes made to that copy inside the method have absolutely no effect on the original variable outside the method.

public void TryToChangeValue(int number)
{
    // 'number' here is a copy of the original argument.
    number = 100; // This only changes the local copy.
}
 
// In your Main method or another method:
int myOriginalNumber = 5;
Console.WriteLine($"Before calling method, myOriginalNumber is: {myOriginalNumber}");
 
TryToChangeValue(myOriginalNumber); // Pass the variable to the method
 
Console.WriteLine($"After calling method, myOriginalNumber is still: {myOriginalNumber}");
// Output will show that myOriginalNumber is still 5!    

This is a safety feature. It prevents methods from unexpectedly modifying your variables without your explicit intent.

Passing a Reference with ref

What if you do want a method to be able to modify the original variable? For this, C# provides the ref keyword. When you use ref, you are no longer passing a copy of the value; instead, you are passing the argument by reference. This means the method receives a direct pointer to the variable's memory location.

Any changes made to the parameter inside the method will affect the original variable that was passed in. You must use the ref keyword in both the method definition and when you call the method.

public void ChangeValueByRef(ref int number)
{
    // 'number' here is a reference to the original variable.
    number = 100; // This WILL change the original variable's value.
}
 
// In your Main method:
int myOriginalNumber = 5;
Console.WriteLine($"Before, original number is: {myOriginalNumber}");
 
ChangeValueByRef(ref myOriginalNumber); // Note 'ref' is used in the call as well
 
Console.WriteLine($"After, original number is: {myOriginalNumber}"); // Output is 100!    

One important rule for ref is that the variable you pass must be initialized before you pass it to the method.

Getting Data Out with out

The out keyword is very similar to ref in that it also passes an argument by reference. However, it has a different contractual meaning and is used for a different purpose: to allow a method to return multiple values.

When you mark a parameter with out, you are telling the compiler:

1. The method must assign a value to this parameter before the method returns.
2. The variable passed as the argument does not need to be initialized before the method call.

A perfect real-world example of this is the int.TryParse() method. It tries to convert a string to an integer. If it succeeds, it returns true and gives you the converted number. If it fails, it returns false without throwing a program-crashing exception.

Console.WriteLine("Please enter a number:");
string? userInput = Console.ReadLine();
 
// We declare 'parsedNumber' but we don't need to initialize it.
// The TryParse method will assign a value to it if successful.
int parsedNumber;
 
// TryParse will attempt to parse the string.
// It returns 'true' if successful and puts the result in our 'parsedNumber' variable.
// It returns 'false' if it fails.
if (int.TryParse(userInput, out parsedNumber))
{
    Console.WriteLine($"Success! The number is {parsedNumber}.");
}
else
{
    Console.WriteLine("That was not a valid integer.");
}   

The TryParse method effectively returns two pieces of information: a bool indicating success, and the parsed integer (via the out parameter) if that success occurred. This is a very common and safe pattern in C# for methods that need to return a result along with a status.

Optional Parameters – Providing Defaults

So far, when we've defined a method with parameters, we've had to provide an argument for every single one when we call it. But what if you want to make some parameters optional, giving them a default value if the caller doesn't provide one? C# makes this easy with optional parameters.

You create an optional parameter by simply assigning it a default value in the method signature using the equals sign (=).

The Key Rule

There's one important rule you must follow: all optional parameters must appear after all required (non-optional) parameters in the method's parameter list.

Let's look at a practical example for creating test users:

public void CreateTestUser(string username, string role = "Standard", bool isActive = true)
{
    // Inside this method, 'role' will be "Standard" and 'isActive' will be true
    // unless the caller provides different values.
    Console.WriteLine($"Creating user: {username}, Role: {role}, Active: {isActive}");
}   

This allows us to call the method with increasing levels of detail:

// 1. Provide only the required argument
CreateTestUser("guest_user");
 
// 2. Provide the required argument and the first optional one
CreateTestUser("test_user_1", "Standard");
 
// 3. Provide all arguments
CreateTestUser("admin_user", "Administrator", true);    

Using Named Arguments to Skip Optional Parameters

What if you want to use the default value for the role parameter but provide a specific value for the isActive parameter? You can't just skip it with a comma like this: CreateTestUser("power_user", , false); – that's invalid syntax!

This is where named arguments come in. They allow you to specify which parameter you are providing a value for by using the parameter's name followed by a colon (:). This lets you skip any optional parameters in the middle.

// We want to use the default role ("Standard") but set isActive to false.
// We use a named argument for 'isActive'.
CreateTestUser("power_user", isActive: false);
 
// You can even change the order of arguments if you name them!
CreateTestUser(role: "Guest", isActive: false, username: "another_user");

Combined Output:

Creating user: guest_user, Role: Standard, Active: True
Creating user: test_user_1, Role: Standard, Active: True
Creating user: admin_user, Role: Administrator, Active: True
Creating user: power_user, Role: Standard, Active: False
Creating user: another_user, Role: Guest, Active: False    

Optional and named arguments work together to make your methods much easier to call for common use cases while still providing flexibility for more complex ones.

A Quick Look at in and params

To round out your knowledge, there are two other parameter modifiers you might see.

The in Parameter

The in keyword is like a "read-only" version of ref. It passes the argument by reference (avoiding a copy), but it prevents the method from modifying the value of the argument. This is primarily a performance optimization used with large struct types, as it avoids the overhead of copying the entire structure while still guaranteeing the original data won't be changed. For now, just be aware it exists.

The params Keyword

The params keyword allows a method to accept a variable number of arguments of the same type. It must be the last parameter in a method definition, and you can only have one params parameter per method. Inside the method, the arguments are treated as an array.

This is incredibly useful for creating flexible utility methods.

public static double Average(params double[] numbers)
{
    if (numbers.Length == 0)
    {
        return 0;
    }
 
    double sum = 0;
    foreach (double num in numbers)
    {
        sum += num;
    }
 
    return sum / numbers.Length;
}
 
// Now you can call it with any number of arguments!
double avg1 = Average(10, 20); // 15
double avg2 = Average(5, 10, 15, 20); // 12.5
double avg3 = Average(3.14); // 3.14
double avg4 = Average(); // 0    

The Console.WriteLine method itself uses params to allow for its string formatting capabilities!