C# - optional parameters

Optional parameters in C# allow you to define parameters in methods with default values. This means you can call the method without providing values for those parameters, as they already have defaults set in the method signature.

We can make method’s parameters optional in C# in many different ways which are as follow:

1. Specify parameter default values
2. By using parameter array
3. Method over-loading
4. Using optional attribute

Let’s try to understand them one by one with example:

1. Specify parameter default values:

In C#, optional parameters enable setting default values for method parameters. This allows calling the method without specifying values for those parameters, as they have defaults defined in the method signature. Let's illustrate this concept with an example:

using System;

public class OptionalParametersExample
{
    // Method with optional parameters using default values
    public void Greet(string name = "Guest", int age = 0)
    {
        Console.WriteLine($"Hello, {name}! You are {age} years old.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        OptionalParametersExample example = new OptionalParametersExample();

        // Calling the method without providing parameters
        example.Greet(); // Output: Hello, Guest! You are 0 years old.

        // Providing only one parameter
        example.Greet("Alice"); // Output: Hello, Alice! You are 0 years old.

        // Providing both parameters explicitly
        example.Greet("Bob", 30); // Output: Hello, Bob! You are 30 years old.

        Console.ReadLine();
    }
}

This code demonstrates a Greet method within the OptionalParametersExample class that has two parameters, name and age, with default values. When calling this method without specific arguments, it utilizes the default values. If only one argument is given, it assumes it's for name and uses the default for age. When both arguments are provided, they replace the defaults.

Upon running this code, you'll see different greetings based on how the Greet method is called, showcasing the functionality of optional parameters with default values in C#.

Output:

Hello, Guest! You are 0 years old.
Hello, Alice! You are 0 years old.
Hello, Bob! You are 30 years old.

2. By using Parameter array:

In C#, an optional parameter using a params array allows a method to accept a variable number of arguments, including none. Let's illustrate this concept with an example:

using System;

public class OptionalParamsArrayExample
{
    // Method with an optional params array
    public void DisplayNumbers(params int[] numbers)
    {
        if (numbers.Length == 0)
        {
            Console.WriteLine("No numbers provided.");
        }
        else
        {
            Console.Write("Numbers provided: ");
            foreach (int number in numbers)
            {
                Console.Write($"{number} ");
            }
            Console.WriteLine();
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        OptionalParamsArrayExample example = new OptionalParamsArrayExample();

        // Calling the method with different numbers of arguments
        example.DisplayNumbers(); // Output: No numbers provided.
        example.DisplayNumbers(1, 2, 3); // Output: Numbers provided: 1 2 3
        example.DisplayNumbers(5, 10, 15, 20, 25); // Output: Numbers provided: 5 10 15 20 25

        Console.ReadLine();
    }
}
  

This code example showcases a DisplayNumbers method within the OptionalParamsArrayExample class that accepts an optional params array of integers named numbers. You can call this method with varying numbers of integer arguments or even without any arguments.

When running this program, it displays different outputs based on how the DisplayNumbers method is called, illustrating the functionality of an optional parameter using a params array in C#.

Output:

No numbers provided.
Numbers provided: 1 2 3
Numbers provided: 5 10 15 20 25

3. Using method overloading:

In C#, you can establish optional parameters using method overloading by defining multiple versions of a method, each with a different number of parameters. This allows you to call the method with various sets of arguments. Let's illustrate this concept with an example:

using System;

public class OptionalParameterOverloadingExample
{
    // Method overloading to create optional parameters
    public void DisplayInfo(string name)
    {
        Console.WriteLine($"Hello, {name}!");
    }

    public void DisplayInfo(string name, int age)
    {
        Console.WriteLine($"Hello, {name}! You are {age} years old.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        OptionalParameterOverloadingExample example = new OptionalParameterOverloadingExample();

        // Calling the methods with different numbers of arguments
        example.DisplayInfo("Alice"); // Output: Hello, Alice!
        example.DisplayInfo("Bob", 30); // Output: Hello, Bob! You are 30 years old.

        Console.ReadLine();
    }
}
  

In this code, the `OptionalParameterOverloadingExample` class has two overloaded methods named `DisplayInfo`, each with a different number of parameters. When these methods are called, the compiler determines which version to execute based on the number of arguments provided.

Upon running this program, you'll see distinct outputs depending on how the `DisplayInfo` methods are called, showcasing the use of method overloading to create optional parameters in C#.

Output:

Hello, Alice!
Hello, Bob! You are 30 years old.

4. By using 'Optional' attribute:

In C#, you can explicitly define optional parameters using the Optional attribute from the System.Runtime.InteropServices namespace. This attribute allows specifying default values for parameters directly in the method signature. Let's see an example:

using System;
using System.Runtime.InteropServices;

public class OptionalAttributeExample
{
    // Method with optional parameters using 'Optional' attribute
    public void DisplayGreeting(string message, [Optional] string name = "Guest")
    {
        Console.WriteLine($"{message}, {name}!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        OptionalAttributeExample example = new OptionalAttributeExample();

        // Calling the method with different numbers of arguments
        example.DisplayGreeting("Hello"); // Output: Hello, Guest!
        example.DisplayGreeting("Hi", "Alice"); // Output: Hi, Alice!

        Console.ReadLine();
    }
}
  

In this code, the DisplayGreeting method within the OptionalAttributeExample class has an optional parameter name with the Optional attribute. When calling this method, you can provide one or two arguments. If only one argument is given, the name parameter defaults to "Guest" due to the attribute.

Upon running this program, you'll see different outputs based on how the DisplayGreeting method is called, showcasing the use of the Optional attribute to create optional parameters in C#.

Output:

Hello, Guest!
Hi, Alice!