#optional parameters

[codetonics]

Types of Parameter Passing in C#

The sections that follow explain the different types of parameter passing: * Passing arguments by value * Ref modifier * Out modifier * Implications of passing by reference * Params modifier * Optional parameters * Named arguments Passing Arguments by Value A value parameter is used for input parameter passing. A value parameter corresponds to a local variable that gets its initial value from the argument that is passed for the parameter. Modifications to a value parameter do not affect the argument that is passed for the parameter. Listing 1-18 provides an example of parameter passing. Code Snippet * using System; * namespace Ch01 * { *     class Program *     { *         static void Main(string[] args) *         { *             /* Initializes with 100 */ *             int x = 100; *             Console.WriteLine("Before method call :\t{0}", x); *             /* pass as value to the Increment method*/ *             Increment(x); *             Console.WriteLine("After method call :\t{0}", x); *         } *         /* a is the parameter for the MethodA*/ *         static void Increment(int a) *         { *             ++a; *             Console.WriteLine("Incremented value :\t{0}", a); *         } *     } * } This program produced the output: Before method call : 100 Incremented value : 101 After method call : 100 The call of the Increment method will be passed with the value type; as a result, the increment of the value of parameter a in the Increment method does not update the original value of the X in the Main method. Ref Modifier A reference parameter is used for both input and output parameter passing, and during execution of the method, the reference parameter represents the same storage location as the argument variable. A reference parameter is declared with the ref modifier. The example in Listing 1-19 shows the use of the ref parameter. Example of the Ref Parameter Code Snippet * using System; * namespace Ch01 * { *     class Program *     { *         static void Main(string[] args) *         { *             int x = 100; /* Needs to initialize x */ *             Console.WriteLine(x); /* 100 */ *             Increment(ref x); /* pass the location (0x052de8b4) of the x */ *             Console.WriteLine(x); /* 101 */ *         } *         static void Increment(ref int a) /* a pointing to the same memory * * location as x (0x052de8b4) * * of Main method */ *         { ++a; } *     } * } This program will produce the output:100 101 Out Modifier An output parameter is used for output parameter passing. An output parameter is similar to a reference parameter except that the initial value of the caller-provided argument is not necessary. An output parameter is declared with the out modifier. Listing 1-20 provides an example of the use of an out modifier. Example of the Out ModifierCode Snippet * using System; * namespace Ch01 * { *     class Program *     { *         static void Main(string[] args) *         { *             int x; /* Does not need to initialize x */ *             SetInitialValue(out x); *             Console.WriteLine(x); /* 1 */ *         } *         static void SetInitialValue(out int a) *         { a = 1; } *     } * } This program will produce the output: 1 Implications of Passing by Reference When an argument passes by reference to a method, the same storage location is used to access that variable. In above Listing x and a refer to the same location. Params Modifier A parameter array permits a variable number of arguments to be passed to a method. A parameter array is declared with the params modifier. Only the last parameter of a method can be a parameter array, and the type of a parameter array must be a single dimensional array type. Listing 1-21 provides an example of the use of the params modifier. Example of the Params Modifier Code Snippet * using System; * namespace Ch01 * { *     class Program *     { *         static void Main(string[] args) *         { *             string[] planets = { "Jupiter", "\n", "Pallas" }; *             Console.WriteLine("{0}", ConcatStrings(planets)); *         } *         static string ConcatStrings(params string[] items) *        { *             string result = default(string); *             foreach (string item in items) *             { result = string.Concat(result, item); } *             return result; *         } *     } * } This program will produce the output: Jupiter Pallas Optional Parameters A parameter can be optional if the default value for the parameter is specified in its declaration, as shown in Listing below. Example of the Optional Parameters Code Snippet * using System; * namespace Ch01 * { *     class Program *     { *         static void Main(string[] args) *         { *             Show(); /* Please specify message */ *             Show("Message set"); /* Message set */ *         } *         static void Show(string message = "Please specify message") *         { *             Console.WriteLine(message); *         } *     } * } This program will produce the output: Please specify message Message set Named Arguments A named argument is used to identify the argument by name instead of its position. Listing provides an example of the named argument. Example of the Named Arguments Code Snippet * using System; * namespace Ch01 * { *     class Program *     { *         static void Main(string[] args) *         { *             Add(a: 10, b: 10); /* 20 */ *             Add(10, b: 10); /* 20 */ *             //Add(a: 10, 10); /* Compile time error, position */ *         } *         static void Add(int a, int b) *         { *             Console.WriteLine(a + b); *         } *     } * } This program will produce the output:20 20 http://dlvr.it/4dlzHL

[elia]

Awkward Rails 2 routes

Don't use parenthesis to mark a parameter as optional in a Rails 2 route

[joshuaenfield]

.NET4 - Optional Parameters with Named Arguments and Overloads

I am a fan of Jon Skeet. If you don't know who Jon Skeet is and write C# you probably haven't immersed yourself in the community much. Jon is not on the C# language team, but he is prolific on answering community questions and understanding every corner of the language in ways the normal mortals like us cannot approach. He has the highest reputation on StackOverflow. In addition, Jon is a phenomenal communicator in regard to concepts, and he should be especially considering he has answered almost 20,000 questions on C# asked by green programmers like myself. 

So when Jon writes articles I usually read them. I've read two of his books. So when I found out he was doing a C# Mastery Video series I couldn't resist watching even the basics.

Let me jump gears for a moment now that I have convinced you of the pure awesome that is Jon Skeet ....ahem the Chuck Norris of languages...let me give you a little more context on optional parameters before we get into the meat of this post.

What are optional parameters and how do they work?

Optional parameters allows you to specify default values for method parameters. Optional parameters are implemented by embedding the default parameter and value as a metadata attribute on the method in the compiled code. Callers of methods using optional parameters must know to use this metadata if it exists to make use of "optional parameters". I put optional parameters in quotes because optional parameters are sort of "faked" in that the caller looks at the default values and substitutes those into the call to the real method. This means the method being called no idea about the optional parameters. It just receives the optionals as normal arguments. The caller is what looks up the information and makes the substitutions. 

So what happens when you use optional parameters is the compiler if it supports optional parameters looks at the method you are calling and sees if it has optional parameters and then sticks those in for you when you don't supply them.

A big catch to be aware of with optional parameters is what we call a versioning problem. This means you need to be careful when working with different assemblies to take into account the above information when you have client assemblies using assemblies with optional parameters.

Overloads vs. Optionals?

Now you can implement optional parameters or alternatively use overloads. Why would you want to use one or the other?

Overloads [in contrast to Optionals]

Cons

More code to write [and sometimes this is alot of code - just 4 optionals covers 24 overloads]

Documentation must also be duplicated [if documented properly].

Doesn't comply with DRY as much as optionals

May be more code to maintain and less flexible due to needing to change every caller overload when a base method is altered.

Pros

Adding an overload never breaks the client assemblies using the old calls when deploying assemblies seperately.

As an extension of the above you don't need to worry about versioning issues.

Sometimes seen as more object oriented.

Can be cleaner and lead to smaller methods breaking functions into extensions of functionality and the base functionality.

Optional parameters basically have the inverse of this with one more interesting twist. When combined with named arguments they become quite powerful.

I never thought of named parameters going hand in hand with optional parameters prior to seeing Jon show them in this way in these mastery videos I was watching on TekPub. Then I realized hey this is pretty cool.

See the tricky thing with optional parameters previously is that if you wanted to supply an argument in the middle of a bunch of optional parameters you actually had to supply all of the arguments up to that optional parameter. Named parameters allow you to supply any arguments you want to supply in any position. This is simply a fantastic result of these two features being used together.

Optional parameters come with gotchas in some cases. Overloads do not.

Why Optional Parameters can be Better

Personally I don't really see a problem with using optional providing clients outside of your control are not making direct use of the code base. Optional Parameters are so much cleaner than 3 or 4+ overloads. It's really annoying when you open up a class and see 16 overloads, and even more confusing when code is split up all over the place. Optional parameters would break this down into one method. In addition the construct makes for something much more readable and immediately understandable than overloads. More than anything optional parameters remove extra unnecessary bloat and extra code to maintain.

It is worth emphasizing the named parameters alone are a great feature and don't require optional parameters to be used with them.

It would be an interesting exercise to write an extension to the compile process that transforms optional into overloads (thus making optional parameters simply an alternative cleaner form of defining overloads). I am actually a little curious why the actual process doesn't work this way.

Joshua Enfield