1. IronPDF
  2. IronPDF Blog
  3. .NET Help
  4. C# Default Parameters

Published August 30, 2023

C# Default Parameters (How it Works For Developers)

Today, we will delve into the world of C# and learn about a powerful feature - Default Parameters. We'll break it down in an easy-to-understand way, focusing on the concept of default argument value and optional arguments in C#.

What are Default Parameters?

In C#, default parameters, also known as optional argument parameters, allow you to assign a value to fixed arguments in a method definition. If an argument for that parameter is not provided when the function is called, it will use the default.

A default parameter value is set in the method definition like this as shown below in them code snippet below:

public void Greet(string name = "Friend")
{
    Console.WriteLine("Hello, " + name);
}
public void Greet(string name = "Friend")
{
    Console.WriteLine("Hello, " + name);
}
Public Sub Greet(Optional ByVal name As String = "Friend")
	Console.WriteLine("Hello, " & name)
End Sub
VB   C#

Here, the parameter name is an optional attribute. The string "Friend" is the default value. If you call Greet() without passing an argument, "Friend" will be used as the value for the name.

Required Parameters and Optional Parameters

Required Parameters

A required parameter is a parameter that must be included when the function or method is called. It doesn't have a default value, so an argument must always be provided. The compiler checks the call to the function or method, and if the required parameter is not supplied, it throws a compile-time error.

Let's consider an example:

//pass arguments in the same order
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
//pass arguments in the same order
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
'pass arguments in the same order
Public Sub IntroduceYourself(ByVal firstName As String, ByVal lastName As String)
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub
VB   C#

In this method, firstName and lastName are both required parameters. When you call IntroduceYourself, you must provide values for both parameters. If you omit arguments, you'll get a compile-time error.

IntroduceYourself("John", "Doe"); // Following call is correct
IntroduceYourself("John"); // Error: lastName is missing
IntroduceYourself("John", "Doe"); // Following call is correct
IntroduceYourself("John"); // Error: lastName is missing
IntroduceYourself("John", "Doe") ' Following call is correct
IntroduceYourself("John") ' Error: lastName is missing
VB   C#

Optional Parameters

On the other hand, optional parameters allow flexibility. They have a default value set within the method definition, which is used when the method is called without that parameter.

For instance, let's modify the IntroduceYourself method to make the lastName parameter optional:

//named arguments
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
//named arguments
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
'named arguments
Public Sub IntroduceYourself(ByVal firstName As String, Optional ByVal lastName As String = "Doe")
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub
VB   C#

Now, you can call IntroduceYourself with just the firstName parameter. If you do, lastName will default to "Doe".

IntroduceYourself("John", "Smith"); // Outputs: Hello, my name is John Smith
IntroduceYourself("John");          // Outputs: Hello, my name is John Doe
IntroduceYourself("John", "Smith"); // Outputs: Hello, my name is John Smith
IntroduceYourself("John");          // Outputs: Hello, my name is John Doe
IntroduceYourself("John", "Smith") ' Outputs: Hello, my name is John Smith
IntroduceYourself("John") ' Outputs: Hello, my name is John Doe
VB   C#

When you do supply the optional arguments, it overrides the default value.

Remember that in the method declaration, required parameters must always be listed before optional parameters.

Understanding the Difference

The distinction between required or named and optional parameters is significant as it affects how you can call a method. Optional parameters provide flexibility, allowing you to skip input for specific parameters when they aren't needed. On the other hand, required parameters ensure that necessary data is always provided to the function or method, helping to prevent runtime errors.

Rules for Using Default Parameters

When defining a method with default parameters, there are a few key rules to remember:

  1. The default value must be a constant expression. You can't use variables or method calls.
  2. All optional parameters must be defined at the end of the parameter list after any required parameters.
  3. When you call a method with optional parameters, you can provide omitted arguments for the optional parameters in the order they are defined, or you can use named arguments.
  4. The default value will be used if an optional argument value is not provided.

Consider the following code snippet for positional arguments:

static void Main(string[] args)
{
    ShowMessage("Hello");
    ShowMessage("Hello", "John");
}

public static void ShowMessage(string msg, string name = "Friend")
{
    Console.WriteLine(msg + ", " + name);
}
static void Main(string[] args)
{
    ShowMessage("Hello");
    ShowMessage("Hello", "John");
}

public static void ShowMessage(string msg, string name = "Friend")
{
    Console.WriteLine(msg + ", " + name);
}
Shared Sub Main(ByVal args() As String)
	ShowMessage("Hello")
	ShowMessage("Hello", "John")
End Sub

Public Shared Sub ShowMessage(ByVal msg As String, Optional ByVal name As String = "Friend")
	Console.WriteLine(msg & ", " & name)
End Sub
VB   C#

In the static void Main method, we call ShowMessage twice. We only pass one argument the first time, so the name parameter uses its default value of "Friend". We pass two arguments the second time, so "John" is used instead of the default value.

Named and Optional Parameters

C# also supports named and optional parameters. Named parameters allow you to specify a value for a parameter by name rather than by position. This can be helpful when a method has several optional parameters, and you want to provide a value for one but not the others.

In the following example, ShowGreetings has two optional parameters:

public static void ShowGreetings(string greeting = "Hello", string name = "Friend")
{
    Console.WriteLine(greeting + ", " + name);
}
public static void ShowGreetings(string greeting = "Hello", string name = "Friend")
{
    Console.WriteLine(greeting + ", " + name);
}
Public Shared Sub ShowGreetings(Optional ByVal greeting As String = "Hello", Optional ByVal name As String = "Friend")
	Console.WriteLine(greeting & ", " & name)
End Sub
VB   C#

We can call this method with just the first parameter:

ShowGreetings("Hi");
ShowGreetings("Hi");
ShowGreetings("Hi")
VB   C#

Or we can use named arguments to provide a value for the name while omitting the greeting argument:

ShowGreetings(name: "John");
ShowGreetings(name: "John");
ShowGreetings(name:= "John")
VB   C#

What's the benefit of using named parameters?

Named parameters in C# provide several benefits:

  1. Improved Readability: Named parameters can make your code easier to read and understand. By specifying the parameter's name, you make it clear what each argument represents. This can be especially beneficial in methods with multiple parameters.
  2. Flexible Argument Order: With named parameters, you can supply arguments in any order, not just the order that the parameters appear in the method declaration. This can make your code more flexible and improve readability in some cases.
  3. Ease with Optional Parameters: Named parameters are often used with optional parameters. When a method has several optional parameters, you can use these parameters to provide values for some optional parameters, not others. This way, you don't need to provide a value for every optional parameter, only those you want to change from their default values.

Here is another example of named parameters value type:

// Method Declaration
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    // Method body
}

// Method Call
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);
// Method Declaration
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    // Method body
}

// Method Call
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);
' Method Declaration
Public Sub RegisterUser(ByVal username As String, ByVal password As String, Optional ByVal email As String = "", Optional ByVal subscribeToNewsletter As Boolean = False)
	' Method body
End Sub

' Method Call
RegisterUser(username:= "JohnDoe", password:= "password123", subscribeToNewsletter:= True)
VB   C#

In the above code, email is an optional parameter that we've omitted, and we've chosen to set subscribeToNewsletter to true, even though it's the last parameter in the list. Using named parameter makes it clear what each argument represents and allows us only to specify the arguments we want to provide.

Default Parameters and Method Overloading

What is Method Overloading?

In C#, method overloading, or function overload, is a feature that allows you to define multiple methods with the same name but with a different set of parameters. This allows you to perform different operations using the same method name, making your code more intuitive and easier to use.

Consider the following code example of overloaded methods:

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message, string name)
{
    Console.WriteLine(message + ", " + name);
}
public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message, string name)
{
    Console.WriteLine(message + ", " + name);
}
Public Sub DisplayMessage(ByVal message As String)
	Console.WriteLine(message)
End Sub

Public Sub DisplayMessage(ByVal message As String, ByVal name As String)
	Console.WriteLine(message & ", " & name)
End Sub
VB   C#

In the above example, the DisplayMessage method is overloaded. One version of the method takes a single string parameter, and the other takes two string parameters.

Using Default Parameters instead of Overloading

Default parameters can often be used as an alternative to overloading. By providing a default value for a parameter in your method, you can allow the caller to choose whether to supply that parameter. This can give your method the same flexibility as method overloading but with less code.

Here's how you could rewrite the above example using a default parameter instead of overloading:

public void DisplayMessage(string message, string name = "Friend")
{
    Console.WriteLine(message + ", " + name);
}
public void DisplayMessage(string message, string name = "Friend")
{
    Console.WriteLine(message + ", " + name);
}
Public Sub DisplayMessage(ByVal message As String, Optional ByVal name As String = "Friend")
	Console.WriteLine(message & ", " & name)
End Sub
VB   C#

Now, DisplayMessage can be called with either one or two arguments:

DisplayMessage("Hello");
DisplayMessage("Hello", "John");
DisplayMessage("Hello");
DisplayMessage("Hello", "John");
DisplayMessage("Hello")
DisplayMessage("Hello", "John")
VB   C#

In the first call, the name parameter uses its default value of "Friend". In the second call, the supplied argument "John" is used instead.

Remember, the default value for a default parameter must be a constant expression, which means it can't be a variable or a method call. This is because the value needs to be known at compile time.

Iron Software Suite

Let's dive into Iron Software suite, which includes IronPDF, IronXL, IronOCR, and IronBarcode. These powerful libraries are specifically designed to help you extend the capabilities of your C# applications. They can easily be related to the concepts we discussed in the article, including default parameters, named argument specifications, and method overloading.

IronPDF: This is a C# library for converting HTML to PDF, generating PDFs, editing PDFs, and more. Understanding default and optional parameters can be critical when using IronPDF. Many of the methods in IronPDF will have optional parameters, which allow for extensive customization without overcomplicating the method signatures. More about this can be found on the IronPDF HTML to PDF tutorial page. IronXL: This library allows your C# application to read, write, and manipulate Excel files in various formats. Methods in IronXL may have different parameters for things like the format to save a file in or whether to include headers when importing data. You might also find that named and optional parameters are used extensively for specifying cell ranges, formatting options, and more. IronOCR: An advanced Optical Character Recognition (OCR) library that can read text and barcodes from images and PDFs in your C# applications. The methods of IronOCR might have optional parameters for controlling aspects of the OCR process, such as the language of the text, the level of error correction to apply, and so on. Understanding these parameters can give you better control over the OCR process. IronBarcode: This library is a versatile tool for reading and generating barcodes in .NET applications. Here too, understanding default parameters is crucial. When generating a barcode, for instance, you might have optional parameters to specify the size, format, or value of the barcode.

Conclusion

In conclusion, mastering the use of default and optional parameters in C# can significantly enhance your programming efficiency and the versatility of your code. These concepts are fundamental to C#.

Speaking of these libraries, remember that the individual licenses for each start from $749, and these libraries also offer a free trial. However, Iron Software offers a package deal: you can acquire the entire suite for the price of just two individual licenses.