.NET 4.0 and VS 2010 Series – Named and Optional Parameters

Technorati Tags: .NET 4.0,Named Parameters,Optional Parameters,C# 4.0

After my posts on the framework features over the past couple of weeks, I will now start focussing on the language aspects of C# 4.0. In C# 4.0, named and optional parameters have been introduced. This is one feature that I have been waiting for so I am only glad that the .NET team has decided to introduce this feature in C# 4.0.

VB 6.0 programmers are aware of the usage of the optional parameters. It used to be declared as

 Sub DoSomething(Optional ByVal Switch As Boolean = False)

What the above declaration meant was that you could call the DoSomething method without explicitly passing the Switch parameter. The default value of false will be assigned to the variable if it was not passed.

This was not possible in .NET. The workaround was to declare overloaded methods. You do not need to do that anymore. In C# 4.0, you can declare a method with an optional parameter simply by assigning a default value for the parameter in question like the example below.

private string Extract(String inputString, int endIndex=0, int startIndex =0)

Named parameters as the name suggests, enable the developers to skip a parameter while calling the method if they wish to. This is done by passing the parameter by quoting its name and value separated by a colon as shown in the syntax below

Extract(inputString, startIndex: 4);

The syntax above calls the method extract with three parameters the signature of which is described previously. You will notice that the second parameter endIndex has been skipped and the value is being passed for startIndex. Below is the complete code snippet

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.Diagnostics.Contracts;

   6:  

   7:  

   8: namespace NamedOptionalParams

   9: {

  10:     class Program

  11:     {

  12:         static void Main(string[] args)

  13:         {

  14:             String inputString = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  15:             String result = Extract(inputString,6);

  16:             String result1 = Extract(inputString, startIndex: 4);

  17:             String result2 = Extract(inputString, startIndex: 6, endIndex: 10);

  18:             Console.WriteLine(result);

  19:             Console.WriteLine(result1);

  20:             Console.WriteLine(result2);

  21:             Console.ReadLine();

  22:  

  23:         }

  24:  

  25:         //this method creates a substring based on the input parameters

  26:         //1. The input string is always passed

  27:         //2. Start Index is an optional parameter. If this is not passed then the 

  28:         //   start is assumed to be 0 which is the default value

  29:         //3. The End Index can be omitted. If it is omitted, then start Index has to

  30:         //   be passed and the string is from the start index to the end of the input

  31:         //   string

  32:         static string Extract(String inputString, int endIndex=0, int startIndex =0)

  33:         {

  34:  

  35:             if (endIndex==0)

  36:             {

  37:                 endIndex = inputString.Length;

  38:             }

  39:  

  40:             String outString = inputString;

  41:             outString = inputString.Substring(startIndex, (endIndex - startIndex));

  42:             

  43:             return outString;

  44:         }

  45:     }

  46: }

In the above example, the extract method just creates a substring for a specified start and end index. I have made three calls to the method. Note that with Named Parameters, the order in which you pass the parameters is not important as long as you don’t forget to name them correctly. You can see this in Line 17 of the above code.

That is it for this post on named and optional parameters. They are quite a useful feature that will reduce the number of overloaded methods that we will have to write. I am sure you will find more ways of putting them to use.