Force a derived class to call a base method with implementation

Question

I have a class A which derives from class B:

public class B
{
   protected void Run() // pass data here used by all 3 Run methods
   {
     BeforeRun();
     RunInternal();
     AfterRun();
   }

   private void RunInternal()
   {

   }

   private void BeforeRun()
   {

   }

   private void AfterRun()
   {

   }
}

public class A : B
{

}

What is the nearest achievement I can get to force the user who inherits from class B MUST call the base method Run() ?

Add protected, virtual, abstract, etc... where you want, I am free to do changes where you suggest.

Answer 1

You can't require someone to call a method, except for the constructor. But a class's behavior shouldn't be in the constructor or called from the constructor. A class shouldn't start doing something just because we instantiated it. It should do something when we call its methods.

When we design a class it typically has one or two methods which are the primary responsibility of that class. Whoever creates an instance of the class is going to call one or more of those methods because that's the only reason why the class exists.

Instead of adding another method and expecting others to call it, you design the class so that the primary methods cannot be overridden. The only public methods are in the base class. The methods that get overridden aren't public. That way the base class methods always get called, and if there's something you want the base class to always do, it always gets done.

That way other classes don't change the required base class behavior. They only extend it.

public abstract class TheBaseClass
{
    public void DoSomething()
    {
        AlwaysDoThis();
        InheritedClassBehavior();
    }

    private void AlwaysDoThis()
    {  
        //This method in the base class always gets called.
        //You don't need to explicitly require someone
        //to call it.
    }

    protected abstract void InheritedClassBehavior();   
}

public class TheInheritedClass : TheBaseClass
{
    protected override void InheritedClassBehavior()
    {
        //The inherited class has its own behavior here.
        //But this method can't be called directly because
        //it's protected. Someone still has to call
        //DoSomething() in the base class, so AlwaysDoThis()
        //is always called.
    }
}

InheritedClassBehavior is protected, so nothing can call it directly. The only way to call it is by calling DoSomething, which will always call the method in the base class, AlwaysDoThis().

InheritedClassBehavior is abstract, so inherited classes must implement it. Or you could make it virtual - it has an implementation in the base class but an inherited class can override it. (If there aren't any abstract methods then the base class doesn't need to be abstract. The base class would only be abstract if you want to prevent creating instances of the base class, only allowing creation of inherited classes.)

Answer 2

Your best option is to have a base implementation in A (so make it virtual), and only override it in the derived classes if they need to change the behavior of Run().

Anything that calls Run() will get the base implementation unless there has been an override supplied. There is no way you can force the override to call the base, classical OO simply doesn't work like that.

You should also be careful of calling a virtual method from a constructor - Resharper will warn you about this (because an override may get called, and this is unknown to the base implementation).

But other than that, there is no way within C# to force a derived class to call a particular method - a derived class extends the base class, so to force this sort of behavior would break basic OO concepts. Even if you put the calls into a constructor in the base class there is no guarantee that a derived class will invoke that constructor. You can force the base class to call the derived class (use an abstract base method, this must be implemented in the derived class), the derived method can then call back to a base method; but this in itself is a bit of a work around that is really a waste of time unless some of the derived classes are actually going to add some functionality to Run().

One other approach to consider is to use a product like PostSharp - it allows you to use attributes on methods to achieve a cross cutting pattern. This still doesn't force a derived class to call base implementations, but it may be a convenient way to achieve what you are wanting (cross cutting is used for auditing or logging patterns, where a specific method must be called when another method is invoked).