optional-parameters

If I have a constructor with say 2 required parameters and 4 optional parameters, how can I avoid writing 16 constructors or even the 10 or so constructors I'd have to write if I used default parameters (which I don't like because it's poor self-documentation)? Are there any idioms or methods using templates I can use to make it less tedious? (And easier to maintain?) You might be interested in the Named Parameter Idiom . To summarize, create a class that holds the values you want to pass to your constructor(s). Add a method to set each of those values, and have each method do a return *this;

Both of these generate an error saying they must be a compile-time constant: void Foo(TimeSpan span = TimeSpan.FromSeconds(2.0)) void Foo(TimeSpan span = new TimeSpan(2000)) First of all, can someone explain why these values can't be determined at compile time? And is there a way to specify a default value for an optional TimeSpan object? You can work around this very easily by changing your signature. void Foo(TimeSpan? span = null) { if (span == null) { span = TimeSpan.FromSeconds(2); } ... } I should elaborate - the reason those expressions in your example are not compile-time constants is

Let's say I've got a PHP function foo: function foo($firstName = 'john', $lastName = 'doe') { echo $firstName . " " . $lastName; } // foo(); --> john doe Is there any way to specify only the second optional parameter? Example: foo($lastName='smith'); // output: john smith PHP does not support named parameters for functions per se. However, there are some ways to get around this: Use an array as the only argument for the function. Then you can pull values from the array. This allows for using named arguments in the array. If you want to allow optional number of arguments depending on context,

This question already has an answer here: Should you declare methods using overloads or optional parameters in C# 4.0? 13 answers which one is better? at a glance optional parameter seems better (less code, less XML documentation, etc), but why do most MSDN library classes use overloading instead of optional parameters? Is there any special thing you have to take note when you choose to use optional parameter (or overloading)? One good use case for 'Optional parameters' in conjunction with 'Named Parameters' in C# 4.0 is that it presents us with an elegant alternative to method overloading

Does C# 4.0 allow optional out or ref arguments? As already mentioned, this is simply not allowed and I think it makes a very good sense. However, to add some more details, here is a quote from the C# 4.0 Specification , section 21.1: Formal parameters of constructors, methods, indexers and delegate types can be declared optional: fixed-parameter: attributes opt parameter-modifier opt type identifier default-argument opt default-argument: = expression A fixed-parameter with a default-argument is an optional parameter , whereas a fixed-parameter without a default-argument is a required

I noticed that with the optional parameters in C# 4 if you specify a parameter as optional on an interface you DON'T have to make that parameter optional on any implementing class: public interface MyInterface { void TestMethod(bool flag = false); } public class MyClass : MyInterface { public void TestMethod(bool flag) { Console.WriteLine(flag); } } and therefore: var obj = new MyClass(); obj.TestMethod(); // compiler error var obj2 = new MyClass() as MyInterface; obj2.TestMethod(); // prints false Does anyone know why optional parameters are designed to work this way? On one hand I suppose