C# Optional Parameters Explained

March 18, 2025 3 minutes read

C# optional parameters enable methods, constructors, indexers and delegates to be called without specifying all arguments. This simplifies method calls and improves readability by reducing the need for multiple overloads. First, let’s highlight that:

Each optional parameter has a default value defined in its declaration.
If no argument is provided, the parameter uses its default value.
The default value must be a compile-time constant expression.
Optional parameters must be placed at the end of the parameter list declaration.

In this post, we’ll explore how to define and use optional parameters in C#.

Index

Defining Optional Parameters

Here’s the syntax for defining a method with optional parameters:

public void DisplayMessage(string message, int repeatCount = 1, bool showCount = false) {
    for (int i = 0; i < repeatCount; i++) {
        if(showCount) { Console.Write(i.ToString() + " "); }
        Console.WriteLine(message);
    }
}

public void DisplayMessage(string message, int repeatCount = 1, bool showCount = false) {

for (int i = 0; i < repeatCount; i++) {

if(showCount) { Console.Write(i.ToString() + " "); }

Console.WriteLine(message);

}

In the above example:

message is a required parameter.
repeatCount and showCount are optional parameters with a default value of 1 and false.

Using Optional Parameters At Call Site

To use the method defined with optional parameters, you can omit arguments for one or more optional parameters. The compiler will automatically substitute the default values.

// Calls DisplayMessage with repeatCount = 1 and showCount = false
DisplayMessage("Hello, world!"); 

// Calls DisplayMessage with repeatCount = 3 and showCount = false
DisplayMessage("Hello, world!", 3);

// Calls DisplayMessage with repeatCount = 5 and showCount = true
DisplayMessage("Hello, world!", 5, true);

// Calls DisplayMessage with repeatCount = 1 and showCount = false

DisplayMessage("Hello, world!");

// Calls DisplayMessage with repeatCount = 3 and showCount = false

DisplayMessage("Hello, world!", 3);

// Calls DisplayMessage with repeatCount = 5 and showCount = true

DisplayMessage("Hello, world!", 5, true);

However the position of each optional parameter matters. To provide a value for the second optional parameter, a value must be provided for the first one:

// Compile error CS1503: cannot convert from 'bool' to 'int'
DisplayMessage("Hello, world!", true);

1 2	// Compile error CS1503: cannot convert from 'bool' to 'int' DisplayMessage("Hello, world!", true);

In the example above, the caller of DisplayMessage() can still use a named argument to skip the first optional parameter and provide a value for the second one:

DisplayMessage("Hello, world!", showCount: true);

1	DisplayMessage("Hello, world!", showCount: true);

Optional Parameters for Constructors

Optional parameters are not only useful in methods but also provide significant advantages when used in constructors. They can greatly simplify object initialization, allowing for flexible instantiation with varying amounts of provided information. This is particularly useful in classes with multiple properties where only a few are essential, and others can be sensibly defaulted. Here’s an example:

public class UserProfile {
    public string Username { get; set; }
    public string Email { get; set; }
    public int Age { get; set; }
    public bool IsSubscribed { get; set; }

    // Constructor with required and optional parameters
    public UserProfile(string username, string email, 
                       int age = 25, bool isSubscribed = true) {
        Username = username;
        Email = email;
        Age = age;
        IsSubscribed = isSubscribed;
    }
}

public class UserProfile {

public string Username { get; set; }

public string Email { get; set; }

public int Age { get; set; }

public bool IsSubscribed { get; set; }

// Constructor with required and optional parameters

public UserProfile(string username, string email,

int age = 25, bool isSubscribed = true) {

Username = username;

Email = email;

Age = age;

IsSubscribed = isSubscribed;

}

Optional Parameters for Indexers

Optional parameters can work with C# indexers. Here is a small example that illustrates this C# feature:

var persons = new Persons();
// ...
var johnFullDesc = persons["John"];          // Here maxLength = int.MaxValue
var johnTruncatedDesc = persons["John", 10]; // Here maxLength = 10

class Persons {

   private readonly Dictionary<string, string> m_DicoPersonDesc = new Dictionary<string, string>();

   // Optional parameter for indexer
   public string this[string name = "hello", int maxLength = int.MaxValue] {
      get {
         var desc = m_DicoPersonDesc[name];
         if(desc.Length > maxLength) {
            desc= desc.Substring(0, maxLength);
         }
         return desc;
      }
}

var persons = new Persons();

// ...

var johnFullDesc = persons["John"]; // Here maxLength = int.MaxValue

var johnTruncatedDesc = persons["John", 10]; // Here maxLength = 10

class Persons {

private readonly Dictionary<string, string> m_DicoPersonDesc = new Dictionary<string, string>();

// Optional parameter for indexer

public string this[string name = "hello", int maxLength = int.MaxValue] {

get {

var desc = m_DicoPersonDesc[name];

if(desc.Length > maxLength) {

desc= desc.Substring(0, maxLength);

}

return desc;

}

Rules for Optional Parameters

Default Value Must be Constant: The default value for an optional parameter must be a compile-time constant, such as a number, string, default(type), null, an enumeration constant, new ValueType() where ValueType is a structure and no argument are passed to its constructor.
Optional Parameters at the End: All optional parameters must appear after all required parameters in the parameter list.
No Overloads with Same Signature: You cannot define overloads that would create ambiguity when the method is called with omitted arguments.

Benefits of Using Optional Parameters

Reduces Method Overloads: By using optional parameters, you can avoid defining multiple method overloads for different scenarios.
Enhances Readability: Code that uses optional parameters is often more readable and concise than using numerous overloaded methods.
Increases Flexibility: Optional parameters provide greater flexibility in method invocation.

Optional Parameters Under the Hood

One might assume that the C# compiler generates multiple overloaded methods in IL code, but fortunately, it doesn’t—avoiding code bloat. Instead, IL code inherently supports optional parameters. For example, our DisplayMessage() method compiles to:

.method assembly hidebysig static void DisplayMessage(
		string message,
                // Notice the [opt] for optional parameter marker
		[opt] int32 repeatCount,
		[opt] bool showCount
	) cil managed 
{
	.custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (
		01 00 00 00
	)
        //  Below are default value handling
	.param [2] = int32(1)
	.param [3] = bool(false)

	.maxstack 2
	.locals init (
		[0] int32 i,
		[1] bool,
		[2] bool
	)

	IL_0000: nop
	IL_0001: ldc.i4.0
	IL_0002: stloc.0
        ...

.method assembly hidebysig static void DisplayMessage(

string message,

// Notice the [opt] for optional parameter marker

[opt] int32 repeatCount,

[opt] bool showCount

) cil managed

{

.custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (

01 00 00 00

)

// Below are default value handling

.param [2] = int32(1)

.param [3] = bool(false)

.maxstack 2

.locals init (

[0] int32 i,

[1] bool,

[2] bool

)

IL_0000: nop

IL_0001: ldc.i4.0

IL_0002: stloc.0

...

Conclusion

C# optional parameters enhance flexibility and readability, reducing the need for method overloads and simplifying maintenance. By following best practices, you can keep your code clear and efficient.