Question

First look at this code:

class Program
{
  static void Main(string[] args)
  {
    var x =(Base) new Derived();
    ((IMethod)x).DoWork();

    Console.ReadKey();
  }
}

interface IMethod
{
  void DoWork();
}

abstract class Base : IMethod
{
  void IMethod.DoWork()
  {
    Console.WriteLine("Base.DoWork");
  }
}

class Derived : Base, IMethod
{
  public void DoWork()
  {
    //here I where I want to call base.DoWork();
    Console.WriteLine("Derived.DoWork"); 
  }
}

Output:

Derived.DoWork

Desired:

Base.DoWork
Derived.DoWork

I’m dealing with an API that exposes an interface that when implemented, the DoWork method will be called at some part of the procession.

Now in the above example, the class Base is a part of the API, that internally (in the API) already explicitly implements that interface and does some important executions in the DoWork method.

I need to override the implementation of the IMethod in my derived class as well, so I get notified when needed, the problem is I can’t ‘override’ the method and call the base method, neither can I cast base to IMethod.

Any solution?

Note: reflection won’t work since it’s a Silveright project, and private method invoking is prohibited.

Answer 1

I’ve found DanBryant’s comment to be the answer, although as he mentions is a bit risky since we can’t assure the implementer will call the base method, but is a decent way tho.

I made a protected virtual method that is called from the private interface implementer, then, in the derived class, instead of worrying about the interface, I just care about overriding the base class and calling the base implementation from it, that works perfect, example:

abstract class Base : IMethod
{
  void IMethod.DoWork()
  {
    DoWork();
  }

  protected virtual void DoWork()
  {
    Console.WriteLine("Base.DoWork");
  }
}

class Derived : Base
{
  protected override void DoWork()
  {
    base.DoWork();
    //here I where I want to call base.DoWork();
    Console.WriteLine("Derived.DoWork");
  }
}