C# Default Parameter Value

Welcome to The Coding College! In this tutorial, we will explore the default parameter values in C#, a powerful feature that simplifies method calls and enhances code readability.

What Are Default Parameter Values in C#?

A default parameter value is a value assigned to a method’s parameter that gets used if the caller does not supply an argument for that parameter. This helps make methods more flexible and reduces the need for method overloading in some cases.

Why Use Default Parameter Values?

  1. Simplifies method calls by avoiding the need to specify arguments every time.
  2. Reduces the number of method overloads required.
  3. Improves code readability and maintainability.

Syntax of Default Parameters

To define a default parameter, you assign a value to the parameter in the method declaration.

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

Example:

public static void Greet(string name = "Guest")
{
    Console.WriteLine("Hello, " + name + "!");
}

How Default Parameter Values Work

  1. If an argument is provided, the method uses the provided value.
  2. If no argument is provided, the method uses the default value.

Example:

public static void DisplayMessage(string message = "Welcome to C#!")
{
    Console.WriteLine(message);
}

public static void Main()
{
    DisplayMessage(); // Uses default value
    DisplayMessage("Hello, World!"); // Overrides default value
}

Output:

Welcome to C#!
Hello, World!

Multiple Default Parameters

You can define multiple default parameters in a method.

Example:

public static void OrderPizza(string size = "Medium", string crust = "Thin Crust", int quantity = 1)
{
    Console.WriteLine($"You ordered {quantity} {size} pizza(s) with {crust}.");
}

public static void Main()
{
    OrderPizza(); // Uses all default values
    OrderPizza("Large"); // Overrides the first default value
    OrderPizza("Small", "Cheese Burst", 2); // Overrides all default values
}

Output:

You ordered 1 Medium pizza(s) with Thin Crust.
You ordered 1 Large pizza(s) with Thin Crust.
You ordered 2 Small pizza(s) with Cheese Burst.

Using Default and Non-Default Parameters Together

When using default and non-default parameters, ensure that all default parameters are declared after the non-default ones. Otherwise, you’ll encounter a compilation error.

Correct:

public static void PrintDetails(string name, int age = 18)
{
    Console.WriteLine($"{name} is {age} years old.");
}

Incorrect:

public static void PrintDetails(int age = 18, string name)
{
    // This will cause a compilation error
}

Named Arguments with Default Parameters

C# allows you to use named arguments with default parameters to make method calls more readable.

Example:

public static void Introduce(string name = "Unknown", string city = "Unknown")
{
    Console.WriteLine($"{name} is from {city}.");
}

public static void Main()
{
    Introduce(city: "New York"); // Named argument for 'city'
}

Output:

Unknown is from New York.

Advantages of Default Parameters

  • Reduces Method Overloading: Instead of creating multiple overloaded methods, you can use a single method with default parameters.
  • Example Without Default Parameters: 
public static void Display(string text)
{
    Console.WriteLine(text);
}

public static void Display()
{
    Console.WriteLine("Default Message");
}
  • Example With Default Parameters: 
public static void Display(string text = "Default Message")
{
    Console.WriteLine(text);
}
  • Improves Code Readability: Default parameters make method calls more concise and easier to understand.
  • Better Code Maintenance: If a default value changes, you only need to update the method definition.

Common Mistakes to Avoid

  • Incorrect Parameter Order: Default parameters must be declared at the end of the parameter list. 
// Wrong
public static void ExampleMethod(string name = "John", int age)
{
}

// Correct
public static void ExampleMethod(int age, string name = "John")
{
}
  • Overloading with Default Parameters: Avoid overloading methods unnecessarily when default parameters suffice.

Conclusion

Default parameter values in C# are an efficient way to simplify method calls and reduce redundancy. By using this feature, you can create more flexible and readable methods while maintaining the integrity of your codebase.

For more tutorials and examples, visit The Coding College, your go-to resource for coding and programming knowledge.

Keep coding smarter with The Coding College! 🚀

Leave a Comment