C# interfaces

Question

What's the difference between Explicitly implement the interface and Implement the interface.

When you derive a class from an interface, intellisense suggest you to do both.

But, what's the difference?

Answer 1

Here you go, directly from MSDN

Answer 2

The difference is that you can inherit a class from several interfaces. These interfaces may have identical Method signatures. An explicit implementation allows you to change your implementation according to which Interface was used to call it.

Answer 3

Explicit will put IInterfaceName. at the front of all of the interface implementations. It's useful if you need to implement two interfaces that contain names/signatures that clash.

More info here.

Answer 4

The IDE gives you the option to do either - it would be unusual to do both. With explicit implementation, the members are not on the (primary) public API; this is handy if the interface isn't directly tied to the intent of the object. For example, the ICustomTypeDescriptor members aren't all that helpful to regular callers - only to some very specific code, so there is no purpose having them on the public API causing mess.

This is also useful if:

• there is a conflict between an interface's Foo method and your own type's Foo method, and they mean different things
• there is a signature conflict between other interfaces

The typical example of the last point is IEnumerable<T>, which has a GetEnumerator() method at two levels in the interface hierarchy - it is common to implement the typed (IEnumerator<T>) version using implicit implementation, and the untyped (IEnumerator) version using explicit implementation.

Answer 5

Explicitly implement puts the fully qualified name on the function name consider this code

    public interface IamSam
    {
     int foo();
     void bar();
    }

    public class SamExplicit : IamSam
    {
     #region IamSam Members

     int IamSam.foo()
     {
      return 0;
     }

     void IamSam.bar()
     {

     }

     string foo()
     {
      return "";
     }
     #endregion
    }

    public class Sam : IamSam
    {
     #region IamSam Members

     public int foo()
     {
      return 0;
     }

     public void bar()
     {

     }

     #endregion
    }

IamSam var1;
var1.foo()  returns an int.
SamExplicit var2;
var2.foo() returns a string.
(var2 as IamSam).foo() returns an int.

Answer 6

Another aspect of this:

If you implicitely implemented, it means that the interface members are accessible to users of your class without them having to cast it.

If it's explicitely implemented, clients will have to cast your class to the interface before being able to access the members. Here's an example of an explicit implementation:

    interface Animal
{
    void EatRoots();
    void EatLeaves();
}

interface Animal2
{
    void Sleep();
}


class Wombat : Animal, Animal2
{
    // Implicit implementation of Animal2
    public void Sleep()
    {
    }

    // Explicit implementation of Animal
    void Animal.EatRoots()
    {

    }

    void Animal.EatLeaves()
    {
    }

}

Your client code

Wombat w = new Wombat();
w.Sleep();
w.EatRoots();   // This will cause a compiler error because it's explicitely implemented
((Animal)w).EatRoots();  // This will compile

Answer 7

Explicit interface implementation, where the implementation is hidden unless you explicitly cast, is most useful when the interface is orthogonal to the class functionality. That is to say, behaviorally unrelated .

For example, if your class is Person and the interface is ISerializable, it doesn't make much sense for someone dealing with Person attributes to see something weird called 'GetObjectData' via Intellisense. You might therefore want to explicitly implement the interface.

On the other hand, if your person class happens to implement IAddress, it makes perfect sense to see members like AddressLine1, ZipCode etc on the Person instances directly (implicit implementation).

Answer 8

Here's the difference in plain English:

Suppose you have an interface Machine, which has a function Run(), and another interface Animal which also has a function called Run(). Of course, when a machine runs, we're talking about it starting up, but when an animal runs, we're talking about it moving around. So what happens when you have an object, lets call it Aibo that is both a Machine and an Animal? (Aibo is a mechanical dog, by the way.) When Aibo runs, does he start up, or does move around? Explicitly implementing an interface lets you make that distinction:

interface Animal
{
 void Run();
}
interface Machine
{
 void Run();
}

class Aibo : Animal, Machine
{
 void Animal.Run()
 {
  System.Console.WriteLine("Aibo goes for a run.");
 }
 void Machine.Run()
 {
  System.Console.WriteLine("Aibo starting up.");
 }
}
class Program
{
 static void Main(string[] args)
 {
  Aibo a = new Aibo();
  ((Machine)a).Run();
  ((Animal)a).Run();
 }
}

The catch here is that I can't simply call a.Run() because both of my implementations of the function are explicitly attached to an interface. That makes sense, because otherwise how would the complier know which one to call? Instead, if I want to call the Run() function on my Aibo directly, I'll have to also implement that function without an explicit interface.