How to call a base function that's an explicit interface implementation?

Question

Basic problem (pseudocode):

interface ISomethingDoer
{
   void DoSomething();
}

class A: ISomethingDoer
{
   void ISomethingDoer.DoSomething()
   {
      Something.Do();
   }
}

class B: A, ISomethingDoer
{
   void ISomethingDoer.DoSomething()
   {
      if (reason)
      {
         base.DoSomething(); //this does not compile
      }
      SomethingElse.Do();
   }
}

Is there any way to make this work without removing the explicit implementation from class A?

Not without reflection. – Lasse V. Karlsen May 19 '20 at 14:01 — Lasse V. Karlsen, May 19 '20 at 14:01

ProgrammingLlama · Answer 1 · 2020-05-19T14:27:47.637

I would suggest changing your base class a little such that DoSomething calls a protected method:

class A: ISomethingDoer
{
   void ISomethingDoer.DoSomething()
   {
       DoSomethingImpl();
   }

   protected void DoSomethingImpl()
   {
       Something.Do();
   }
}

And then in B you can call DoSomethingImpl:

class B: A, ISomethingDoer
{
   void ISomethingDoer.DoSomething()
   {
      if (reason)
      {
         DoSomethingImpl(); //this does compile
      }
      SomethingElse.Do();
   }
}

The alternative method suggested by Lasse V. Karlsen is to use reflection:

class B: A, ISomethingDoer
{
   void ISomethingDoer.DoSomething()
   {
      if (reason)
      {
         string baseName = $"{typeof(ISomethingDoer).FullName}.{nameof(DoSomething)}";
         MethodInfo baseMethod = this.GetType().BaseType
             .GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
             .FirstOrDefault(m => m.IsPrivate && m.IsFinal && m.Name == baseName);
          baseMethod.Invoke(this, new object[0]);
      }
      SomethingElse.Do();
   }
}

But I don't like this approach since it uses reflection and is going to be slower. I used this answer to help me build the reflection solution.

You can use GetParameters() if you need to filter different overloads of the method, and you can specify arguments by building an object[] array containing them in the same positional order.

score 1 · Answer 2 · answered May 19 '20 at 14:07

You aren't able to call base on an interface type, but you could refactor your classes to make this possible.

By moving the content of your method into a protected method, you can call it directly by both classes, like this:


interface ISomethingDoer
{
    void DoSomething();
}

class A : ISomethingDoer
{
    void ISomethingDoer.DoSomething()
    {
        _DoSomething();
    }

    protected void _DoSomething()
    {
        Something.Do();
    }
}

class B : A, ISomethingDoer
{
    void ISomethingDoer.DoSomething()
    {
        if (reason)
        {
            base._DoSomething();
        }
        SomethingElse.Do();
    }
}

score 0 · Answer 3 · answered May 19 '20 at 14:09

0

This might be a good basic implementation:

public interface IAnimal
{
    void Eat();
}

public class Animal : IAnimal
{
    public void Eat()
    {
        Console.WriteLine("This Animal is Eating!");
    }
}

public class Shark : Animal
{
    public void Eat(bool useBase)
    {
        if (useBase)
        {
            base.Eat();
        }
        else
        {
            Console.WriteLine("This Shark is devouring everything with 120840128904 teeth");
        }
    }
}

answered May 19 '20 at 14:09

Marco Salerno

5,131
2
12
32

1

Quoting the question: _"Is there any way to make this work **without removing the explicit implementation** from class A?"_ – ProgrammingLlama May 19 '20 at 14:16
@John did I remove it? – Marco Salerno May 19 '20 at 14:17
2

Yes, you did. An explicit interface implementation looks like `void IAnimal.Eat()`, not `public void Eat()`. – ProgrammingLlama May 19 '20 at 14:18
1

providing a parameter that indicates how the method should work internally doesn´t seem good to me. – MakePeaceGreatAgain May 19 '20 at 14:22
@John you are right, anyway I wouldn't even like to find in production such implementation, I guess he can take my answer as another approach to solve the problem. – Marco Salerno May 19 '20 at 14:24
1

@HimBromBeere I think the same, I placed it only for the "reason" variable in his example, which could be something even worse – Marco Salerno May 19 '20 at 14:25
@Macro I agree. I dislike explicit interfaces generally. They are handy when making fluent interfaces without defining loads of classes though. :-D – ProgrammingLlama May 19 '20 at 14:27

score 0 · Answer 4 · answered May 19 '20 at 15:36

I always make private implementation as wrappers to methods.

interface ISomethingDoer
{
    void DoSomething();
}

class A : ISomethingDoer
{
    protected void DoSomething()
    {
        Something.Do();
    }
    void ISomethingDoer.DoSomething() => DoSomething();
}

class B : A, ISomethingDoer
{
    protected void DoSomethingElse()
    {
        if (reason)
        {
            base.DoSomething();
        }
        SomethingElse.Do();
    }
    void ISomethingDoer.DoSomething() => DoSomethingElse();
}

How to call a base function that's an explicit interface implementation?

4 Answers4