blocks|key|3205250|text|因为默认参数在编译时解析，而不是在运行时解析。因此，默认值不属于被调用的对象，而是属于被调用的引用类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3205251|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Because default parameters are resolved at compile time, not runtime.
So the default values does not belong to the object being called, but to the reference type that it is being called through.

blocks|key|3205309|text|一个可选参数只是用一个属性做了标记。这个属性告诉编译器在调用点插入该参数的默认值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3205310|在将obj2.TestMethod();代码编译为IL时，而不是在即时编译时，C#调用将被obj2.TestMethod(false);替换。|offset|length|style|CODE|3205311|因此，在某种程度上，总是由调用者提供带有可选参数的默认值。这也会对二进制版本控制产生影响:如果您更改了默认值，但没有重新编译调用代码，它将继续使用旧的默认值。|3205312|3205313|另一方面，这种断开意味着您不能总是互换地使用具体的类和接口。|blockquote|3205314|3205315|3205316|如果接口方法是implemented+explicitly，就不能这样做。|3205317|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms173157.aspx^0|0|2|I|19|N|0|0|0|0|0|0|7|M|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@$D|11|E|12|F|G]|$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1A|8|@]|9|@$D|1B|E|1C|1|1D]]|A|$]]|$1|R|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

An optional parameter is just tagged with an attribute. This attribute tells the compiler to insert the default value for that parameter at the call-site.

The call <code>obj2.TestMethod();</code> is replaced by <code>obj2.TestMethod(false);</code> when the C# code gets compiled to IL, and not at JIT-time.

So in a way it's always the caller providing the default value with optional parameters. This also has consequences on binary versioning: If you change the default value but don't recompile the calling code it will continue to use the old default value.

<blockquote>
 On the other hand, this disconnect means you can't always use the concrete class and the interface interchangeably.
</blockquote>

You already can't do that if the interface method was <a href="http://msdn.microsoft.com/en-us/library/ms173157.aspx" rel="noreferrer">implemented explicitly</a>.

blocks|key|3205363|text|据我所知，可选参数有点像宏替换。从方法的角度来看，它们实际上并不是可选的。其中的一个工件就是你看到的行为，如果你转换成一个接口，你会得到不同的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3205364|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Optional parameters are kind of like a macro substitution from what I understand. They are not really optional from the method's point of view. An artifact of that is the behavior you see where you get different results if you cast to an interface.

blocks|key|282678|text|更新：This+question+was+the+subject+of+my+blog+on+May+12th+2011.+Thanks+for+the+great+question!|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|282679|假设您有一个如您所描述的接口，以及一百个实现它的类。然后，您决定将该接口的一个方法的一个参数设为可选。您是否建议编译器应该强制开发人员找到该接口方法的每个实现，并将参数设为可选？|282680|假设我们这样做了。现在假设开发人员没有实现的源代码：|282681|282682|//+in+metadata:
public+class+B+
{+
++++public+void+TestMethod(bool+b)+{}
}|code-block|syntax|javascript|282683|282684|//+in+source+code
interface+MyInterface+
{+
++++void+TestMethod(bool+b+=+false);+
}
class+D+:+B,+MyInterface+{}
//+Legal+because+D's+base+class+has+a+public+method+
//+that+implements+the+interface+method|282685|D的作者应该如何做到这一点？在你的世界里，他们是否需要打电话给B的作者，让他们给他们发一个新版本的B，让这个方法有一个可选的参数？|282686|那是不会飞起来的。如果两个人打电话给B的作者，其中一个人希望缺省值为true，而另一个人希望默认值为false，该怎么办？如果B的作者只是简单地拒绝一起玩呢？|282687|也许在这种情况下，他们会被要求说：|282688|class+D+:+B,+MyInterface+
{
++++public+new+void+TestMethod(bool+b+=+false)
++++{
++++++++base.TestMethod(b);
++++}
}|282689|拟议的功能似乎为程序员增加了许多不便，但没有相应地增加代表性能力。此功能的显著优势是什么，可以证明用户增加的成本是合理的？|282690|282691|更新:在下面的评论中，supercat建议了一种语言功能，它将真正地增加语言的功能，并支持一些类似于这个问题中描述的场景。仅供参考，该功能--接口中方法的默认实现--将被添加到C#+8中。|282692|entityMap|0|LINK|mutability|MUTABLE|url|https://ericlippert.com/2011/05/12/optional-argument-corner-cases-part-two/^0|3|2H|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|E|5|6|7|1F|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1G|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|I|3|J|5|K|7|1I|8|@]|9|@]|C|$L|M]]|$1|N|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]|$1|O|3|P|5|K|7|1K|8|@]|9|@]|C|$L|M]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|C|$]]|$1|W|3|X|5|K|7|1O|8|@]|9|@]|C|$L|M]]|$1|Y|3|Z|5|6|7|1P|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|11|3|12|5|6|7|1R|8|@]|9|@]|C|$]]|$1|13|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]]|14|$15|$5|16|17|18|C|$19|1A]]]]

UPDATE: <a href="https://ericlippert.com/2011/05/12/optional-argument-corner-cases-part-two/" rel="noreferrer">This question was the subject of my blog on May 12th 2011. Thanks for the great question!</a>

Suppose you have an interface as you describe, and a hundred classes that implement it. Then you decide to make one of the parameters of one of the interface's methods optional. Are you suggesting that the right thing to do is for the compiler to force the developer to find every implementation of that interface method, and make the parameter optional as well?

Suppose we did that. Now suppose the developer did not have the source code for the implementation:

<hr>

<pre><code>// in metadata:
public class B 
{ 
 public void TestMethod(bool b) {}
}
</code></pre>

<hr>

<pre><code>// in source code
interface MyInterface 
{ 
 void TestMethod(bool b = false); 
}
class D : B, MyInterface {}
// Legal because D's base class has a public method 
// that implements the interface method
</code></pre>

How is the author of D supposed to make this work? Are they required in your world to call up the author of B on the phone and ask them to please ship them a new version of B that makes the method have an optional parameter? 

That's not going to fly. What if two people call up the author of B, and one of them wants the default to be true and one of them wants it to be false? What if the author of B simply refuses to play along?

Perhaps in that case they would be required to say:

<pre><code>class D : B, MyInterface 
{
 public new void TestMethod(bool b = false)
 {
 base.TestMethod(b);
 }
}
</code></pre>

The proposed feature seems to add a lot of inconvenience for the programmer with no corresponding increase in representative power. What's the compelling benefit of this feature which justifies the increased cost to the user?

<hr>

UPDATE: In the comments below, supercat suggests a language feature that would genuinely add power to the language and enable some scenarios similar to the one described in this question. FYI, that feature -- default implementations of methods in interfaces -- will be added to C# 8.

blocks|key|3205419|text|我只想在这里补充我的观点，因为其他答案确实提供了合理的解释，但不是完全让我满意的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3205420|可选参数是编译时在调用点注入默认值的语法糖。这与接口/实现没有任何关系，它完全可以看作是带有可选参数的方法的副作用。所以，当你调用这个方法时，|3205421|public+void+TestMethod(bool+value+=+false)+{+/*...*/+}|code-block|syntax|javascript|3205422|和SomeClass.TestMethod()一样，它实际上也是SomeClass.TestMethod(false)。如果在接口上调用此方法，则从静态类型检查开始，方法签名具有可选参数。如果在没有可选参数的派生类的实例上调用此方法，则在静态类型检查中，方法签名没有可选参数，并且必须使用完整参数调用。|offset|length|style|CODE|3205423|由于可选参数的实现方式，这是自然的设计结果。|3205424|entityMap^0|0|0|0|1|M|W|R|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Just want to add my take here, as the other answers do provide reasonable explanations, but not ones that fully satisfy me.
Optional parameters are syntactic sugar for compile-time injection of the default value at the call site. This doesn't have anything to do with interfaces/implementations, and it can be seen as purely a side-effect of methods with optional parameters. So, when you call the method,
<pre><code>public void TestMethod(bool value = false) { /*...*/ }
</code></pre>
like <code>SomeClass.TestMethod()</code>, it is actually <code>SomeClass.TestMethod(false)</code>. If you call this method on an interface, from static type-checking, the method signature has the optional parameter. If you call this method on a deriving class's instance that doesn't have the optional parameter, from static type-checking, the method signature does not have the optional parameter, and must be called with full arguments.
Due to how optional parameters are implemented, this is the natural design result.

blocks|key|282723|text|var+obj+=+new+MyClass();++++++++
obj.TestMethod();+//+compiler+error

var+obj2+=+new+MyClass()+as+MyInterface;
obj2.TestMethod();+//+prints+false|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|282724|使用|unstyled|282725|MyInterface+obj+=+new+MyClass();++++++++
obj.TestMethod();+//+compiler+error

var+obj2+=+new+MyClass()+as+MyInterface;
obj2.TestMethod();+//+prints+false|282726|并且两者都会导致false|282727|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>var obj = new MyClass(); 
obj.TestMethod(); // compiler error

var obj2 = new MyClass() as MyInterface;
obj2.TestMethod(); // prints false
</code></pre>
Use
<pre><code>MyInterface obj = new MyClass(); 
obj.TestMethod(); // compiler error

var obj2 = new MyClass() as MyInterface;
obj2.TestMethod(); // prints false
</code></pre>
and both result in false

blocks|key|2991793|text|感谢您的解释@eric-lippert|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2991794|下面是一些代码示例：|2991795|[Fact]
public+void+TestOptionalMethodArgument()
{
++++var+implementation+=+new+TestHello();
++++IHello+@interface+=+implementation;

++++Assert.Equal(23,+@interface.Action());
++++Assert.Equal(40,+implementation.Action());
}

public+class+TestHello+:+IHello
{
++++public+int+Action(int+number+=+40)
++++++++=>+number;
}

public+interface+IHello
{
++++int+Action(int+number+=+23);
}|code-block|syntax|javascript|2991796|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Thanks for your explanation @eric-lippert
Here is some code example:
<pre class="lang-cs prettyprint-override"><code>[Fact]
public void TestOptionalMethodArgument()
{
 var implementation = new TestHello();
 IHello @interface = implementation;

 Assert.Equal(23, @interface.Action());
 Assert.Equal(40, implementation.Action());
}

public class TestHello : IHello
{
 public int Action(int number = 40)
 =&gt; number;
}

public interface IHello
{
 int Action(int number = 23);
}
</code></pre>

I noticed that with the optional parameters in C# 4 if you specify an optional parameter on an interface you don,t have to make that parameter optional on any implementing class:

<pre><code>public interface MyInterface
{
 void TestMethod(bool flag = false);
}

public class MyClass : MyInterface
{
 public void TestMethod(bool flag)
 {
 Console.WriteLine(flag);
 }
}
</code></pre>

and therefore:

<pre><code>var obj = new MyClass(); 
obj.TestMethod(); // compiler error

var obj2 = new MyClass() as MyInterface;
obj2.TestMethod(); // prints false
</code></pre>

Does anyone know why optional parameters are designed to work this way?

On one hand I suppose the ability to override any default values specified on the interfaces is useful though to be honest I'm not sure if you should even be able to specify default values on the interface as that should be an implementation decision.

On the other hand, this disconnect means you can't always use the concrete class and the interface interchangeably. This of course, wouldn't be a problem if the default value is specified on the implementation, but then if you're exposing your concrete class as the interface (using some IOC framework to inject the concrete class for instance) then really there's no point having the default value as the caller will have to always provide it anyway.

Why are C# 4 optional parameters defined on interface not enforced on implementing class?

编译器

我注意到，在C# 4中使用可选参数时，如果您在接口上指定了一个可选参数，则t必须使该参数在任何实现类上都是可选的：public interface MyInterface{    void TestMethod(bool flag = false);}public class MyClass : MyInterface...

问为什么在接口上定义的C# 4可选参数在实现类时不强制执行？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在接口上定义的C# 4可选参数在实现类时不强制执行？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在接口上定义的C# 4可选参数在实现类时不强制执行？
EN