如何选择是实现接口还是显式实现接口？
实现接口的方法有两种：
interface IMyInterface
{
void Foo();
}
class IImplementAnInterface : IMyInterface
{
public void Foo()
{
}
}
// var foo = new IImplementAnInterface();
// foo.Foo(); //Ok
// ((IMyInterface)foo).Foo(); //Ok
class IExplicitlyImplementAnInterface : IMyInterface
{
void IMyInterface.Foo()
{
}
}
// var foo = new IExplicitlyImplementAnInterface();
// foo.Foo(); //ERROR!
// ((IMyInterface)foo).Foo(); //Ok
不同之处在于，如果接口是显式实现的，则在允许调用 Foo 方法之前，必须将其实际上强制转换为给定接口。
如何决定使用哪一个？
There are two ways to implement an interface:
interface IMyInterface
{
void Foo();
}
class IImplementAnInterface : IMyInterface
{
public void Foo()
{
}
}
// var foo = new IImplementAnInterface();
// foo.Foo(); //Ok
// ((IMyInterface)foo).Foo(); //Ok
class IExplicitlyImplementAnInterface : IMyInterface
{
void IMyInterface.Foo()
{
}
}
// var foo = new IExplicitlyImplementAnInterface();
// foo.Foo(); //ERROR!
// ((IMyInterface)foo).Foo(); //Ok
The difference is that if the interface is explicitly implemented, it must actually be cast as the given interface before someone's allowed to call the Foo method.
How does one decide which to use?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（4）
如果存在冲突（两个接口具有相同签名的方法，或者您的类/基类和接口以相同的方式发生冲突），并且您不希望冲突的方法具有相同的主体，那么您必须使用显式接口。
否则，您可以自由选择。如果你想隐藏一些已实现的方法，你可以选择显式方法。例如，字典<,>类使用 ICollection<> 的一些方法来完成此操作。接口，因为隐藏的方法会让人们感到困惑。
If there are collisions (two interfaces have a method with the same signature, or your class/base class and an interface collide the same way), and you don't want the colliding methods to have the same bodies, then you have to use explicit interfaces.
Otherwise, you are free to choose. If you want to hide some implemented methods, you choose the explicit method. For example, the Dictionary<,> class does it with some methods of the ICollection<> interface, because the hidden methods would confuse people.
在某些情况下，您必须提供显式实现，例如在实现 IEnumerable 和 IEnumerable<> 时。其中两个接口都公开一个 GetEnumerator 方法。
我遵循的一个一般规则是，如果我实现一个接口，但提供额外的更方便和类型安全的方法和属性来公开接口功能，我将显式地实现该接口。这使得类公开的公共接口更合适，同时仍然允许可能依赖于实现的接口的算法来访问接口提供的方法和属性。
这很难说，但我希望这是有道理的。
There are cases where you have to provide an explicit implementation for example when implementing IEnumerable and IEnumerable<> where both interfaces expose a
GetEnumeratormethod.One general rule I follow is if I implement an interface but provide additional more convient and typesafe methods and properties to expose the interface functionality, I would exlicitly implement the interface. This makes public interface the class exposes more appropriate, while still allowing algorithms that might rely on the implemented interface to access the interface provided methods and properties.
That was hard to word, but I hope it makes some sense.
我只在实现多个接口并且它们都包含同名方法的情况下推荐这样做。
您还可以显式实现一个方法来有效地“隐藏”它，并使用更好的名称实现等效方法。 System.IO.Stream 就是这样做的，显式实现 Dispose 并提供更好命名的 Close()。
有关详细信息，请参阅此 MSDN 文章：http://msdn.microsoft.com/en-我们/library/ms229034.aspx。
I would only recommend this in cases where multiple interfaces are being implemented, and they both contain a method of the same name.
You can also explicitly implement a method to effectively "hide" it and implement an equivalent method with a better name. System.IO.Stream does this, implementing Dispose explicitly and providing the better-named Close().
See this MSDN article for more: http://msdn.microsoft.com/en-us/library/ms229034.aspx.
它最常被视为 .NET 禁止“返回类型协方差”的解决方法。
It's most commonly seen as a workaround for .NET forbidding "return type covariance".