Optional Parameters in C#.NET

Generator Code-39 in C#.NET Optional Parameters

int answer = addit(10, 4),

int answer = addit(10, 4, 5, 12);

So why are optional parameters dangerous Because sometimes default values can have unintended consequences For instance, you don t want to make a divideit method and default the parameters to 0 Someone could call it and get an undebuggable division by zero error Setting the optional values in additall to 1 inside the method body would be bad

public static int addit(int z, int y, int x = 0, int w = 0, int v = 1) { //You CLEARLY don t want this return z + y + x + w + v; }

And sometimes problems can be very subtle, so use optional parameters carefully For instance, say you have a base class, and then a derived class that implements the base, like this:

public abstract class Base { public virtual void SomeFunction(int x = 0) {} } public sealed class Derived { public override void SomeFunction(int x = 1) {} }

Base ex1 = new Base(); ex1 SomeFunction (); Base ex2 = new Derived(); ex2 SomeFunction (); Derived ex3 = new Derived(); ex3 SomeFunction (); // SomeFunction (0)

// SomeFunction (0)

// SomeFunction (1)

What happened here Depending on how you implement the classes, the default value for the optional parameter is set differently The first example, ex1, is an implementation of Base, and the default optional parameter is 0 In the second example, ex2 is cast to a type of Derived (which is legal, since Derived is a subclass of Base) and the default value is also 0 However, in the third example, Derived is instantiated directly and the default value is 1 This is not particularly expected behavior, though I have to admit that I am not sure WHAT expected behavior is in a case like this No matter how you slice it, it s a gotcha and something to watch out for

A reference type, as Book 1 discusses, types a variable that stores reference to actual data, instead of the data itself Reference types are usually referred to as objects, though this is a little inaccurate since everything in the NET Framework is an object New reference types are implemented with Class Interface Delegate These need to be built before you use them; class itself isn t a reference type, but the Calendar class is There are three built-in reference types in the NET Framework: String (who knows why this isn t a static type) Object Dynamic You can pass a reference type into a method just like you can pass a static type It is still considered a parameter You still use it inside the method like any other variable But can reference types be passed, like static types can Let s try For instance, if we have a Schedule method for our Calendar class, we could pass in the CourseId or we could pass in the whole Course It all depends on how we structure the application

public class Course { public int CourseId; public string Name; public void Course(int id, string name)

{ CourseId = id; Name = name; } } public class Calendar { public static void Schedule(int courseId) { } public static void Schedule(Course course) { //Something interesting happens here } }

In this example, we have an overloaded method for Schedule one that accepts a CourseId and one that accepts a Course reference type The second is a reference type, because Course is a class, rather than a static type, like the Integer of the CourseId What if we want the second Schedule method to support an optional Course parameter Say, if I just want it to create a New Course by default if I omit the parameter This would be similar to setting a static integer to 0 or whatever, wouldn t it

public static void Schedule(Course course = New Course()) { //Implementation here }

This isn t allowed, however Visual Studio allows optional parameters only on static types, and the compiler tells you so If I want to do this, I have to accept the CourseId in the Schedule method and construct a new Course in the body of the event