Parameter Modifiers - ref, out, and in

Vaibhav • September 14, 2025

In C#, parameters are normally passed by value, which means the method receives a copy of the argument. Parameter modifiers - ref, out, and in - change this behavior. Understanding them is crucial for controlling how data flows into and out of methods.

Default Parameter Behavior: Pass by Value

By default, when you pass a variable to a method, the method works on a **copy** of that variable. Changes inside the method do not affect the original variable outside. 

void Increment(int number)
{
    number++;
    Console.WriteLine("Inside method: " + number);
}

int x = 5;
Increment(x);
Console.WriteLine("Outside method: " + x);

Explanation: Inside the method, number increases to 6. Outside, x remains 5, because only a copy was modified.

The ref Modifier

Use ref to pass a variable by reference. The method can read and modify the original variable. Both the caller and the method must declare ref. 

void Double(ref int number)
{
    number *= 2;
}

int x = 10;
Double(ref x);
Console.WriteLine(x);  // Output: 20

Analogy: Lending a book to a friend who can write in it - changes are visible to you.

Only use ref when you need the method to update the caller's variable. Overusing ref can make code harder to follow.

The out Modifier

The out modifier is similar to ref but is intended for **output-only** variables. The caller does not need to initialize the variable; the method must assign it before returning. 

void GetCoordinates(out int x, out int y)
{
    x = 5;
    y = 10;
}

int a, b;
GetCoordinates(out a, out b);
Console.WriteLine($"Coordinates: ({a}, {b})");

Analogy: Giving someone an empty box (out variable) to fill - you will get a value, but the initial state doesn't matter.

out is useful when a method needs to return **multiple values** without using arrays, objects, or tuples.

The in Modifier

Introduced in later versions of C#, in passes a variable by reference but ensures the method **cannot modify** it. It's typically used with large structs for performance. 

void Display(in int number)
{
    Console.WriteLine(number);
    // number++; // Error! Cannot modify an 'in' parameter
}

int x = 42;
Display(in x);
Console.WriteLine(x); // Output: 42

Analogy: Lending a book to a friend who can only read - they cannot change its content.

Parameter Modifiers at a Glance

Modifier Caller Initialization Method Can Modify Use Case
ref Required Yes Update caller’s variable
out Not required Yes (must assign) Return multiple values
in Required No Pass large structs efficiently, read-only

Best Practices

  • Prefer returning values over ref/out when possible.
  • Use ref for methods that naturally modify the caller’s data.
  • Use out for methods that need to return **multiple values** without creating new types.
  • Use in when passing large structs that should not be modified.
  • Document your method parameters clearly so callers know which are input, output, or read-only.

Both ref and out parameters result in the variable being passed by reference at the machine level. However, out guarantees assignment before use, helping avoid uninitialized variable bugs.

Common Pitfalls

  • Calling a method with ref without initializing the variable first.
  • Failing to assign an out parameter before returning.
  • Overusing ref or out for unrelated logic - can reduce readability.
  • Confusing ref and out - they serve different purposes.

Summary

Parameter modifiers are a powerful tool to control how methods interact with variables. ref allows full read/write access to the caller’s variable, out enables multiple outputs without pre-initialization, and in allows efficient, read-only access. Use them judiciously and document their behavior to maintain readable and maintainable code.