How does one choose whether to implement an interface or explicitly implement an interface?

Question

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?

NB: The second declaration is invalid with `public` there. You don't need an access modifier, as explicitly implemented interface members are made `private` automatically. — Mark H, Dec 29 '10 at 18:36
I think the answer to your question is entirely subjective, and dependant on the problem your trying to solve. — asawyer, Dec 29 '10 at 18:37
@asawyer: Yes -- I'm looking for a general rule-of-thumb -- not necessarily gospel. — Billy ONeal, Dec 29 '10 at 18:38

score 5 · Accepted Answer · answered Dec 29 '10 at 18:37

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.

Chris Taylor · Answer 2 · 2010-12-29T19:11:54.960

There are cases where you have to provide an explicit implementation for example when implementing IEnumerable and IEnumerable<> where both interfaces expose a GetEnumerator method.

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.

score 1 · Answer 3 · answered Dec 29 '10 at 18:45

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.

score 0 · Answer 4 · answered Dec 29 '10 at 19:02

0

It's most commonly seen as a workaround for .NET forbidding "return type covariance".

answered Dec 29 '10 at 19:02

Ben Voigt

277,958
43
419
720

How does one choose whether to implement an interface or explicitly implement an interface?

4 Answers4