C# - Default Parameter Value

Default Parameter Values in C#

Introduction

In C#, methods can have parameters to accept inputs. Sometimes, you may want to provide default values for parameters so that the caller can omit those arguments, making method calls simpler and more flexible. This feature, called default parameter values, was introduced in C# 4.0. It enables developers to assign default values to parameters, which will be used when no argument is provided for those parameters during method calls.

This document provides a comprehensive explanation of default parameter values in C#, including syntax, rules, examples, and best practices. We'll also cover related concepts like optional parameters, named arguments, and their interplay with default values, along with common interview questions.

What Are Default Parameter Values?

A default parameter value is a value that a method parameter assumes if no argument is provided by the caller. This allows the method to have fewer required arguments while maintaining flexibility.

For example, consider a method to print messages with an optional severity level. You can assign a default severity so callers don't always have to specify it.

Basic Syntax

public void PrintMessage(string message, string severity = "Info")
{
    Console.WriteLine($"[{severity}] {message}");
}

Here, the severity parameter has a default value of "Info". If you call PrintMessage("Hello"), it prints [Info] Hello. If you specify PrintMessage("Error occurred", "Error"), it prints [Error] Error occurred.

How to Define Default Parameter Values

Defining Default Values

To assign a default value to a parameter, you specify an assignment in the method signature after the parameter type and name:

parameterType parameterName = defaultValue

Example:

public void Greet(string name = "Guest")

Types of Default Values Allowed

• Literal constants: int x = 10, bool flag = true, string s = "Hello"
• Enum values: DayOfWeek day = DayOfWeek.Monday
• null for reference types or nullable value types
• Note: You cannot use non-constant expressions as default values (e.g., method calls, new objects)

Examples

public void Log(string message, int level = 1, bool writeToConsole = true)
{
    if (writeToConsole)
        Console.WriteLine($"Level {level}: {message}");
}

Rules and Restrictions

1. Default Parameters Must Appear at the End

Parameters with default values must come after all required parameters. For example, this is valid:

void DoSomething(int x, int y = 5)

This is invalid and causes a compiler error:

void DoSomething(int x = 5, int y)

2. No Non-Constant Default Values

Default parameter values must be compile-time constants, meaning you cannot assign dynamic values such as results from method calls or object creations:

void Method(int x = SomeMethod()); // Invalid

3. Nullable and Reference Types

You can assign null as a default for reference types and nullable value types:

public void Display(string text = null)
{
    if (text == null)
        Console.WriteLine("No text provided");
    else
        Console.WriteLine(text);
}

Calling Methods with Default Parameters

Omitting Optional Arguments

When calling a method, you can omit arguments for parameters that have default values:

PrintMessage("Hello");
// severity parameter is omitted, defaults to "Info"

Specifying Some Optional Arguments

If you want to specify a value for one default parameter but not others, you can use named arguments to clarify:

Log("Starting process", writeToConsole: false);

Using Named Arguments

Named arguments allow you to pass arguments in any order and improve readability, especially for methods with many parameters.

PrintMessage(severity: "Warning", message: "Check your input");

Example: Combining Default and Named Arguments

public void Connect(string host = "localhost", int port = 80, bool useSsl = false)
{
    Console.WriteLine($"Host: {host}, Port: {port}, SSL: {useSsl}");
}

// Calling
Connect(); 
Connect("example.com");
Connect(port: 8080);
Connect(useSsl: true, host: "secure.example.com");

Optional Parameters vs. Method Overloading

Method Overloading

Before default parameters, multiple versions of a method were created to handle different parameter sets:

public void PrintMessage(string msg)
{
    PrintMessage(msg, "Info");
}

public void PrintMessage(string msg, string severity)
{
    Console.WriteLine($"[{severity}] {msg}");
}

Default Parameters Advantages

• Reduces the number of overloads needed.
• Makes method calls cleaner and simpler.
• Reduces boilerplate code.

When to Prefer Overloading

• When default values are not constant or depend on other parameters.
• When you want to handle parameters differently based on types or logic.

Default Parameter Values with Structs and Enums

Using Structs

You can provide default values using structs as long as they are constants:

public void Configure(Point location = default(Point))
{
    Console.WriteLine($"X: {location.X}, Y: {location.Y}");
}

Using Enums

public enum Status { Started, InProgress, Completed }

public void UpdateStatus(Status status = Status.Started)
{
    Console.WriteLine($"Status: {status}");
}

Compatibility and Version Notes

• Default parameter values were introduced in C# 4.0.
• Prior to C# 4.0, method overloading was the primary way to simulate optional parameters.
• Default values are baked into the calling assembly, so changing default values requires recompilation of callers.

Best Practices for Using Default Parameter Values

• Use default parameters to simplify method calls and reduce overloads.
• Keep default values simple and constant.
• Use named arguments with default parameters to improve readability.
• Be cautious about changing default values in widely used libraries due to binary compatibility issues.
• Prefer method overloading if default behavior requires complex logic.
• Document default parameter values clearly.

Common Mistakes and Pitfalls

Changing Default Values Without Recompiling Callers

If a method’s default parameter value changes but the calling assembly is not recompiled, the old default value will still be used.

Mixing Default Parameters and Overloading

Having overloads that differ only by default parameters can cause ambiguity and compiler errors.

Using Complex Expressions as Default Values

Only compile-time constants are allowed, so complex expressions or method calls are invalid.

Examples and Use Cases

Example 1: Simple Logger

public void Log(string message, string level = "INFO", bool timestamp = true)
{
    if (timestamp)
        Console.WriteLine($"[{DateTime.Now}] [{level}] {message}");
    else
        Console.WriteLine($"[{level}] {message}");
}

Example 2: API Client Method

public string GetData(string url, int timeoutSeconds = 30, bool useCache = true)
{
    // Simulate getting data with optional parameters
    return $"Fetching from {url} with timeout {timeoutSeconds} seconds, cache enabled: {useCache}";
}

Example 3: Complex Default Parameter with Nullable

public void SendNotification(string message, string? userId = null)
{
    if (userId == null)
        Console.WriteLine($"Broadcast: {message}");
    else