Method has to be overridden but isn't abstract?

Question

I want to implement a function in the base class but I also want it to be overridden in the derived classes every time. So it is more like "abstract function but with a body".

What am I looking for? Am I looking for the right thing?

Answer 1

If the base-class has something to say, but you want it overridden "every time", then I would have a pair of methods:

public void DoSomething() {
    //things to do before
    DoSomethingCore();
    //things to do after
}
protected abstract void DoSomethingCore();

Answer 2

If your base class does something in the method, but you want to make sure that every subclass is forced to implement some part of the method, then you want the Template Method pattern, as described in Marc Gravell's answer.

There's no way to provide a default implementation in your base class and still force subclasses to provide their own implementation. You could however create an abstract base class and inherit from it to provide the default implementation, but make that concrete class sealed.

public abstract class FooBase {
    public abstract void DoStuff();
}

public sealed class FooImpl : FooBase {
    public override void DoStuff {
        //default widget-munging code
    }
}

Now any classes which inherit from FooBase have to implement DoStuff(), but you have a default implementation FooImpl from which subclasses may not inherit.

You might also prefer to delegate the responsibility for implementing the method to a separate class, which is passed to the base class in its constructor. That's called the Strategy pattern.

public sealed class Foo {
    private IFooStrategy _strategy;
    public Foo(IStrategy strategy) {
        _strategy = strategy;
    }
    void DoStuff() {
        _strategy.DoStuff();
    }
    public static IFooStrategy DefaultStrategy {
        //return singleton instance of the default strategy
    }
}

Now instead of subclassing Foo, you instead create new implementations of the IFooStrategy interface, and pass those to your Foo instance. So you could either do:

new Foo(Foo.DefaultStrategy);

or

new Foo(new DifferentStrategy());