While most modern programming languages provide some way of declaring optional function parameters, C# doesn't provide a way of directly doing so, despite the fact that VB.Net and .Net's attribute system both support this functionality. This is a subject of some debate currently in the C# community. The C# development team's position seems to boil down to the following: When provided, this feature is usually nothing more than dressing up method overloading with a little syntactic sugar.
When you get right down to it, their position makes some sense. A function with an optional parameter is in reality two different functions: one that assumes some default behavior if the optional parameter is omitted, and another that performs more specific behavior based on the value of the optional parameter if provided. But that doesn't change the fact that using overloaded methods to provide optional parameter support feels a little clunky. It works, but you always wind up writing more code, and you pollute your object interface with the extra method signatures required to support all of your optional parameters. Let's look at some alternatives.
Parameter arrays
If you take a look at the classes found in the common language runtime (CLR), you'll find more than a few with methods that can accept a variable-length list of parameters. One example would be the System.Console.WriteLine method, which has an overloaded declaration that works to support replaceable parameters in the string written to the console. For example, this code:
Console.WriteLine("{0} jumped over {1}.", "The cow", "the moon");produces the following output:
The cow jumped over the moon. Any number of replaceable parameters can be specified in this fashion, which means that the number of arguments passed to the WriteLine method can vary from call to call. C# supports this behavior with the params keyword, which, when used before an array type in a function's argument list, creates a parameter array. You can use this array to fake optional parameters in practice. Check out Listing A for an example of this in action. You can see that this solution works pretty well. The OptionalStrings method may be legally called with no parameters, in which case the parameter array args is simply empty -- in effect, the entire array is optional. Further, the calling function doesn't need to explicitly wrap the parameters it sends in an array, and since the parameter array is an honest-to-goodness array, the called function can easily determine how many parameters it has received. But there are a few caveats:
- There's no enforceable limit to the number of arguments received in this way. You couldn't, for instance, declare the OptionalStrings method to receive a maximum of three optional arguments without writing code to do so at runtime inside the function itself.
- Similarly, there's no way to make the array typesafe. If you need to support multiple types in the parameter array, you're limited to using a lowest-common-denominator approach, usually declaring the parameter array as type Object.
- Only one parameter may be marked using params, and it must be the last parameter in the method's argument list.
- You can't specify an optional out (passed by reference) parameter using this method.
Have your say instantly in the
Tech Update forum. Find out what's where in the new Tech Update with our
Guided Tour. Let the editors know what you think in the
Mailroom.
Tech Update forum. Find out what's where in the new Tech Update with our
Guided Tour. Let the editors know what you think in the
Mailroom.
Talkback
This is a nice article. (one of very few articles available in the internet) on how to get around optional parameters in C#. Some of the hyperlinks like listingA and listingB don't work.
It will be very helpful if we could see your code sample. Thanks.
Nice article.
I found this while searching for a solution/way using optional parameter at C#.
It is very bad that C# doesn't have optional parameters. No solution is good as natural support :(