abstract class vs calling base

Question

I need to give the user some degree of control over a function. So I want to partially implement a class that the user can fully implement. I came up with this solution.

public abstract class A
{
    protected void FunctionA()
    {
        // My implementation here
        FunctionB();
    }

    protected abstract void FunctionB();
}

public class B : A
{
    protected override void FunctionB()
    {
        // User implementation here
    }
}

The other solution is this

public class A
{
    protected virtual void FunctionB()
    {
        // My implementation here
    }
}

public class B : A
{
    protected override void FunctionB()
    {
        base.FunctionB();
        // User implementation here
    }
}

Is there any reason I should use one of these solutions over the other? Does it provide some sort of advantage? Could someone give me some insight on when I should use one solution and not the other?

Answer 1

Your first solution is actually a well known pattern, called the Template Method pattern . It's a good approach if you want to make sure the base method is executed (because FunctionA might do others things besides calling FunctionB ).

In the second solution, it becomes possible for the overriding method to not call the base method. Depending on your scenario, it might be appropriate, or not.