接口的可选参数

使用 c # 4.0——构建一个接口和一个实现该接口的类。我想在接口中声明一个可选参数，并将其反映在类中。所以，我有以下几点:

 public interface IFoo
{
void Bar(int i, int j=0);
}


public class Foo
{
void Bar(int i, int j=0) { // do stuff }
}

这个编译了，但看起来不对。接口需要具有可选参数，否则它不能正确地反映在接口方法签名中。

我是否应该跳过可选参数，直接使用可空类型？或者这种工作是否会按计划进行，不会产生任何副作用或后果？

58499 次浏览
小开
最佳答案

You could consider the pre-optional-parameters alternative:

public interface IFoo
{
void Bar(int i, int j);
}


public static class FooOptionalExtensions
{
public static void Bar(this IFoo foo, int i)
{
foo.Bar(i, 0);
}
}

If you don't like the look of a new language feature, you don't have to use it.

小开

What about something like this?

public interface IFoo
{
void Bar(int i, int j);
}


public static class IFooExtensions
{
public static void Baz(this IFoo foo, int i, int j = 0)
{
foo.Bar(i, j);
}
}


public class Foo
{
void Bar(int i, int j) { /* do stuff */ }
}
小开

What is really strange is that the value you put for the optional parameter in the interface actually makes a difference. I suppose you have to question whether the value is an interface detail or an implementation detail. I would have said the latter but things behave like the former. The following code outputs 1 0 2 5 3 7 for example.

// Output:
// 1 0
// 2 5
// 3 7
namespace ScrapCSConsole
{
using System;


interface IMyTest
{
void MyTestMethod(int notOptional, int optional = 5);
}


interface IMyOtherTest
{
void MyTestMethod(int notOptional, int optional = 7);
}


class MyTest : IMyTest, IMyOtherTest
{
public void MyTestMethod(int notOptional, int optional = 0)
{
Console.WriteLine(string.Format("{0} {1}", notOptional, optional));
}
}


class Program
{
static void Main(string[] args)
{
MyTest myTest1 = new MyTest();
myTest1.MyTestMethod(1);


IMyTest myTest2 = myTest1;
myTest2.MyTestMethod(2);


IMyOtherTest myTest3 = myTest1;
myTest3.MyTestMethod(3);
}
}
}

What is kind of interesting is that if your interface makes a parameter optional the class implementing it does not have to do the same:

// Optput:
// 2 5
namespace ScrapCSConsole
{
using System;


interface IMyTest
{
void MyTestMethod(int notOptional, int optional = 5);
}


class MyTest : IMyTest
{
public void MyTestMethod(int notOptional, int optional)
{
Console.WriteLine(string.Format("{0} {1}", notOptional, optional));
}
}


class Program
{
static void Main(string[] args)
{
MyTest myTest1 = new MyTest();
// The following line won't compile as it does not pass a required
// parameter.
//myTest1.MyTestMethod(1);


IMyTest myTest2 = myTest1;
myTest2.MyTestMethod(2);
}
}
}

What seems to be a mistake however is that if you implement the interface explicitly the value you give in the class for the optional value is pointless. How in the following example could you use the value 9?

// Optput:
// 2 5
namespace ScrapCSConsole
{
using System;


interface IMyTest
{
void MyTestMethod(int notOptional, int optional = 5);
}


class MyTest : IMyTest
{
void IMyTest.MyTestMethod(int notOptional, int optional = 9)
{
Console.WriteLine(string.Format("{0} {1}", notOptional, optional));
}
}


class Program
{
static void Main(string[] args)
{
MyTest myTest1 = new MyTest();
// The following line won't compile as MyTest method is not available
// without first casting to IMyTest
//myTest1.MyTestMethod(1);


IMyTest myTest2 = new MyTest();
myTest2.MyTestMethod(2);
}
}
}

Eric Lippert wrote an interesting series on this exact topic: Optional argument corner cases

小开

You don't have to make the parameter optional in the implementation. Your code will make somewhat more sense then:

 public interface IFoo
{
void Bar(int i, int j = 0);
}


public class Foo
{
void Bar(int i, int j) { // do stuff }
}

This way, it's unambiguous what the default value is. In fact, I'm pretty sure the default value in the implementation will have no effect, since the interface provides a default for it.

小开

The thing to consider is what happens when Mocking frameworks are used, which work based on reflection of the interface. If optional parameters are defined on the interface, default value would be passed based on what is declared in the interface. One issue is that there is nothing stopping you from setting different optional values on the definition.

小开

I also can suggest this:

public interface IFoo
{
void Bar(int i);
void Bar(int i, int j);
}


public class Foo
{
// when "j" has default value zero (0).
void Bar(int i)
{
Bar(i, 0);
}
     

void Bar(int i, int j) {}
}

提交答案