C# - Default Parameter Value

Default Parameter Value in C# 

Introduction to Default Parameter Value in C#

In modern C# programming, developers often need to design flexible and reusable methods. One of the most powerful features that enhances method flexibility is the Default Parameter Value in C#. This feature allows you to assign a default value to a method parameter so that when the caller does not provide an argument, the default value is automatically used.

The concept of C# default parameters was introduced in C# 4.0 and has since become an essential part of method design, especially in large-scale .NET applications. Understanding default arguments in C# helps improve code readability, reduce method overloading, and simplify API design.

In this detailed guide, you will learn:

• What is Default Parameter Value in C#?
• Syntax and rules
• Compile-time behavior
• Practical examples
• Restrictions and limitations
• Comparison with method overloading
• Best practices for real-world applications

What is Default Parameter Value in C#?

A Default Parameter Value (also called Optional Parameter) allows a method parameter to have a predefined value. If the caller does not pass an argument for that parameter, the default value is used automatically.

This feature is useful when:

• You want to reduce method overloading
• You want flexible method calls
• You want to simplify function design
• You want cleaner API implementation

Basic Syntax

returnType MethodName(type parameterName = defaultValue)
{
    // Method body
}

The default value must be assigned at the time of method declaration.

Simple Example of Default Parameter Value in C#

Let’s understand with a basic example.

using System;

class Program
{
    static void Greet(string name = "Guest")
    {
        Console.WriteLine("Hello " + name);
    }

    static void Main()
    {
        Greet();           // Uses default value
        Greet("Meenakshi"); // Uses provided value
    }
}

Output

Hello Guest
Hello Meenakshi

Here, the parameter name has a default value of "Guest". If no argument is provided, "Guest" is automatically used.

Rules for Default Parameters in C#

When working with Optional Parameters in C#, there are important rules to follow:

1. Default Parameters Must Appear at the End

All optional parameters must come after required parameters.

// Correct
void Display(string name, int age = 18)

// Incorrect
void Display(int age = 18, string name)

2. Default Value Must Be Compile-Time Constant

The default value must be:

• A constant value
• null
• default keyword
• new Valuetype()

void PrintNumber(int number = 10)
{
    Console.WriteLine(number);
}

Invalid Example

int x = 5;

void Test(int number = x)  // ERROR: Not a constant
{
}

Using Multiple Default Parameters

You can assign default values to multiple parameters.

using System;

class Calculator
{
    public static int Add(int a = 0, int b = 0)
    {
        return a + b;
    }

    static void Main()
    {
        Console.WriteLine(Add());
        Console.WriteLine(Add(5));
        Console.WriteLine(Add(5, 10));
    }
}

Output

0
5
15

This shows how flexible C# method parameters become with default values.

Default Parameter with Reference Types

Default parameters can also be reference types.

using System;

class Program
{
    static void DisplayMessage(string message = null)
    {
        if (message == null)
        {
            message = "Default Message";
        }

        Console.WriteLine(message);
    }

    static void Main()
    {
        DisplayMessage();
        DisplayMessage("Custom Message");
    }
}

The default value here is null, which is allowed.

Using Default Keyword in Parameters

You can use the default keyword to assign default values.

using System;

class Program
{
    static void ShowValue(int number = default)
    {
        Console.WriteLine(number);
    }

    static void Main()
    {
        ShowValue();
    }
}

For int, default is 0.

Named Arguments with Default Parameters

Default parameters work well with named arguments.

using System;

class Program
{
    static void Display(string name = "Guest", int age = 18)
    {
        Console.WriteLine(name + " is " + age + " years old.");
    }

    static void Main()
    {
        Display(age: 25);
        Display(name: "Meenakshi");
    }
}

Named arguments improve clarity in method calls.

Default Parameters vs Method Overloading

Before optional parameters were introduced, developers used method overloading.

Method Overloading Approach

void Print()
{
    Print("Guest");
}

void Print(string name)
{
    Console.WriteLine(name);
}

Using Default Parameter

void Print(string name = "Guest")
{
    Console.WriteLine(name);
}

Default parameters reduce code duplication and improve maintainability.

How Default Parameter Values Work Internally

In C# programming, default parameter values are resolved at compile time. The compiler substitutes the default value into the calling method.

Important Note: If you change the default value in a library and do not recompile the calling assembly, the old default value will still be used.

Default Parameter in Constructors

Constructors can also use default parameter values.

using System;

class Student
{
    public string Name;
    public int Age;

    public Student(string name = "Unknown", int age = 18)
    {
        Name = name;
        Age = age;
    }
}

This simplifies object creation.

Restrictions of Default Parameters

• Must be compile-time constant
• Cannot use dynamic values
• Optional parameters must be last
• Not suitable when logic-based defaults are needed

If the default depends on runtime conditions, use method overloading instead.

3. Maintain API Stability

Be cautious when changing default values in public APIs.

4. Combine with Named Arguments

Improves readability.

Real-World Use Cases

• Logging methods with default log level
• API methods with optional configuration
• Utility functions
• Configuration settings

Advantages of Default Parameters

• Reduces method overloading
• Improves code readability
• Simplifies method calls
• Enhances maintainability

Disadvantages of Default Parameters

• Versioning issues
• Limited to compile-time constants
• Can reduce clarity if overused

Interview Questions on Default Parameter Value in C#

1. What is an optional parameter in C#?

An optional parameter is a parameter with a default value that can be omitted during method call.

2. Can default parameter values be dynamic?

No, they must be compile-time constants.

3. Where must optional parameters be placed?

They must be placed after required parameters.

The Default Parameter Value in C# is a powerful feature that simplifies method design and improves code flexibility. By understanding how default arguments in C# work internally and applying best practices, developers can write cleaner and more maintainable code.

Whether you're building enterprise applications, APIs, or learning through a C# programming tutorial, mastering optional parameters is essential for professional development in .NET.