Discussion on:

Handling optional parameters in C#

Why do you need optional parameters when you can just overload methods? Pointless..

public void DoSomething(string Name) {
}

public void DoSomething(string Name, int Age) {
}

These two methods accomplish the same work, but with different signatures. There is NO NEED for optional parameters when you can overload methods.

When overloading you expect different implementations for different parameters. When using optional parameters you expect almost the same implementation...

More specifically:

public void DoSomething(string Name, int Age) {
}

public void DoSomething(string Name) {
int DefaultAge = ;

DoSomething(Name, DefaultAge) ;
}

Any additional code is minimized (realize, too, that you need something to declare optional parameters where they're supported).

To me, the explicit overloading is much easier to understand, too (but that's just personal preference). So why not give the maintenance programmers a break?

DON'T EVER ADD optional parameters. The problem with them is that they do not generally require any kind of rules on the parameters. I maintain millions of lines of code and believe me it's a nightmare to figure out which paramters are required and which are not when some fool 10 years ago wrote a sub with 7 optional parameters. They are often abused like this!

public sub DoSOmething(opt1, opt2, opt3, opt4, opt5, opt6, opt7)

Ok... so can I pass 1 and 5? 7 and 3? 2, 3, 4? NO! Guess what I have to go look at the stupid function and read through it for half an hour to figure it out. Optional parameters SUCK. Method overloading is the right answer.

public Sub DoSomething(1, 2)
public Sub DoSometing(1,2,3)
public Sub DoSomething(1,2,3,4,5,6,7)

Now you can see there are 3 valid ways to call this sub, NOT 7! (seven factorial) different ways.

I know this is an old thread but if anybody else finds this they need to think about this fact. It's a nightmare to maintain! There are probably times when the optional parameter approach makes sense, is elegant, and works. But like everything think about what you are doing. If you run into the perfect scenario then by all means do it. But don't create ambiguous code like the example. Even if you are using VB.NET or something else that will support this kind of mess, if the parameters DO have rules that govern which are required at what times and in what groups, method overloading is by far the more clear and more maintainable solution. And it's by far the most common scenario in our millions of lines of code. happy coding!

Why are optional parameters needed? If you do as this article described, you are following poor OOP practice and introducing all sorts of vulnerability. Now you have to add all the error checking for data types etc..., not to mention adding overhead to the running app slowing it down because these choices are made at runtime.

If you use the overloading provided, the posiibility of runtime errors is greatly deminished, and since the choices are made by the compiler, the running app will be faster and les vulnerable.

So again I ask, Why try to force optional params?

If you haven't passed xml as a parameter, try it. You've got all the parameters you'll ever want, or not.

Opt on l Par me ers are a sl ppy and not v ry eff cient. You alw ys pay for sh rtc ts. The additional code for type checking, counting defaulting alone make overloads in C# worth the effort. VB is dead long live C#

Make sensible use of nulls.
You could use nullable types as your parameters e.g.

public static void Test(int? ToReturn)
{
if(ToReturn.HasValue)
{
//do something with ToReturn
}
else
{
//process normally
}
}

Call Test like this:

int i = 0;
Test(i);

or

int? j = null;
Test(j);

Please check this out. C#4.0 has this feature. http://cherupally.blogspot.com/2009/11/c-40-new-features-named-and-optional.html

Starting from Visual Studio 2010 - C# 4.0 will support optional parameters. Documented in the C# Programming Guide: Named and Optional Arguments: http://msdn.microsoft.com/en-us/library/dd264739(VS.100).aspx.

This MSDN page, "Simulating Default Parameters" example demonstrates the use of method overloading to simulate default parameters: http://msdn.microsoft.com/en-us/library/aa287762(VS.71).aspx