CODEWITHSUNDEEP
c#default-parameters
Sunscreen
Sunscreen

Reputation: 3564

C# default parameters workaround

Is there a workaround for default parameters? In C++ I would use 

int foo(int k, bool check = false)

A tedious workaround would be to overload a function. An easier one? (There is no way just adding the variable and checking the calls of the function!!)

Thanks, Sun

Upvotes: 4

Views: 813

Answers (6)

comecme
comecme

Reputation: 6396

To elaborate on Denis Mazourick's answer about using default optional parameters in C# 4.0 and how the default values get compiled into the consuming class, try this.

Create a class library with the following code and build it:

public class ClassWithDefaultParameters {
    public string Msg { get; set; }

    public ClassWithDefaultParameters(string msg = "Hello World") {
        Msg = msg;
    }
}

public class ClassWithConstructorOverloads {
    public string Msg { get; set; }

    public ClassWithConstructorOverloads(string msg) {
        Msg = msg;
    }

    public ClassWithConstructorOverloads() : this("Hello World") {}
}

Now create a console application and reference the dll you just built (not the project, but the actual dll). Place this in your code and build the console application.

    static void Main() {
        var cwdp = new ClassWithDefaultParameters();
        var cwco = new ClassWithConstructorOverloads();

        Console.WriteLine(cwdp.Msg);
        Console.WriteLine(cwco.Msg);
   }

When you run the application, the output will be as you expected:

Hello World
Hello World

Now open up the class library, and change both "Hello World" in "Hello Europe". Recompile the library and copy the dll to the output folder of the console application. Do not rebuild the console application.

When you run the console application again, the output will be:

Hello World
Hello Europe

Probably not what you expected! It's not until you rebuild the console application that both lines will print Hello Europe.

I didn't know this and I think I won't use the default parameters because of this. What's worse is that Microsoft doesn't mention this on the MSDN page.

Upvotes: 2

Bek Raupov
Bek Raupov

Reputation: 3777

well, there is no easier way, you could use param feature, but it is risky as well.

have a look at example for string.Format() where you can use it like:

stringA.Format("{0} is {1}", str1, str2)

that way you can pass any number of params, but it is quite tricky how u consume it and could be quite error prone

Upvotes: 0

Denis Mazourick
Denis Mazourick

Reputation: 1455

The C# (before 4.0) didn't support the default parameters. Even in c# 4.0 the default parameters are a bit different than in C++ - they're stored in metadata and, when you reference the assembly with default parameters, they're compiled into your code. So, if the default value was changed in the future, your code will still pass the OLD default value, which may cause the bad effect. So, use the overloaded functions with a single parameter and double parameters and call the one with more parameters passing the default value. Such approach will have a least side effect.

Upvotes: 10

DaveShaw
DaveShaw

Reputation: 52808

You can use optional parameters in your assemblies if they are build with MSBuild 4.0 (VS2010) even if you are targeting the .Net 2.0 framework.

The syntax is just like you said:

int foo(int k, bool check = false)
{
}

Upvotes: 2

Jahan Zinedine
Jahan Zinedine

Reputation: 14874

In C# 4.0 default and named parameters is supported now.

http://msdn.microsoft.com/en-us/library/dd264739.aspx

Upvotes: 4

Øyvind Bråthen
Øyvind Bråthen

Reputation: 60724

In C#4, you can do the same. So this is allowed:

int foo(int k, bool check = false){
  ...
}

There are also possible to use named arguments in C#4 so you can call this method in many different ways:

foo(10, true);
foo(10);
foo(k: 10, check: true);
foo(check: true, k: 10);

named arguments are useful if you have several optional parameters, and only want to specify one of them that is not the first optional one, or to improve readability on the calling side.

Upvotes: 4

Related Questions