Why am I getting an error in C# when mixing explicit implementation and polymorphism?

Question

I am getting this error:

type Bar does not implement interface IFoo

From this code:

public interface IFoo
{
   void DoA();

   void DoB();
}

public class Foo:IFoo
{

    void IFoo.DoA()
    {

    }

    void IFoo.DoB()
    {


   }
}

public class Bar:Foo
{

     void IFoo.DoA()
      {
          base.doA();

      }

      void IFoo.DoB()
      {
          base.doB();

      }
  }

I am using C# 2.0.

What am I doing wrong?

Answer 1

public class Bar : Foo, IFoo
{ 
    // Your code
}

Answer 2

See n8wrl's answer as to how you should be doing this. See below for the reason why.

You can't explicity implement interface members (void IFoo.DoA()) when implicitly implementing the interface. In other words, because Bar only implements IFoo by virtue of extending Foo, you cannot use explicit implementation.

This will work:

public class Bar : Foo
{
    public void DoA()
    {
        ...
    }

    public void DoB()
    {
        ...
    }

Or this:

public class Bar : Foo, IFoo
{
    void IFoo.DoA()
    {
        ...
    }

    void IFoo.DoB()
    {
        ...
    }

A bigger problem that you'll probably face is that since Foo is not abstract, it must implement DoA and DoB. If you also implement these methods in bar, you will not be doing it polymorphically. You'll be hiding the Foo implementations if the code has a handle to the Bar type.

Answer 3

I have run into this as well. what is 'worse', depending on how you look at it is you can't define the interface implementations to be virtual to be overridden in descendent classes. I have gotten into the habit of doing this:

public class Foo:IFoo
{    
     void IFoo.DoA()
     {
          DoACore();
     }
     void IFoo.DoB()
     {
          DoBCore();
     }
     protected virtual void DoACore()
     {
     }
     protected virtual void DoBCore()
     {
     }
}
public class Bar:Foo
{     protected override void DoACore()
      {
          base.DoACore();
      }
      protected override void DoBCore()
      {
          base.DoBCore();
      }
}

Answer 4

I would suspect the confusion arises over how interfaces were implemented in C++, as abstract classes and multiple inheritance.

In .NET, and interface is simply a contract that says you will implement those methods.

You're code won't compile for the same reason this code wont compile(it would with C++):

public interface IFoo
{
    void DoSomething();
}

public abstract class Foo : IFoo
{
}

Foo is declaring that Foo implements IFoo, it doesn't say anything else about anyone.

If you wanted to force derived classes to implement it you would do:

public interface IFoo
{
    void DoSomething();
}

public abstract class Foo : IFoo
{
    public abstract void DoSomething();
}

Or if you really wanted the interface methods hidden by explicit implementation, then something like n8wrl posted above.

Answer 5

At first, this is not clear what is the task? If the goals was to fix a problem asap, than 'Bar : Foo, IFoo' is the shortest solution.

If you are just trying to learn 'implicit/explicit' interfaces difference, than check this post.

Also notice, that 'n8wrl' solution is arguable. It is ok only if Foo indeed required to implement IFoo explicitly. If no, than there is a simpler way:

public interface IFoo
{
    void DoA();
}

public class Foo : IFoo
{
    public virtual void DoA() {}
}

public class Bar : Foo
{
    public override void DoA() {}
}

Hope this helps.