Template method pattern without inheritance

Question

How can a variant of the Template Method pattern be implemented whereby the concrete class does not inherit from the base class, but the overall feature of the pattern is maintained. The reason it cannot inherit is that it's forced to inherit from another class and multiple-inheritance is unavailable.

For example, suppose the following Tempate Method pattern:

public abstract class BaseClass {
    public void Alpha() {
        Beta();
    }

    public abstract void Beta();

    public void Gamma() {
        Delta();
    }

    public abstract void Delta();

}

public ConcreteClass : BaseClass {
    public override void Beta() {
        Gamma();
    }

    public override void Delta() {
        Console.WriteLine("Delta");
    }
}

...
var object = new ConcreteClass();
object.Alpha(); // will outout "Delta"

How can I achieve the same result without ConcreteClass inheriting BaseClass?

If this is C# then you can't do `BaseClass object = new ConcreteClass()` without ConcreteClass inheriting BaseClass. What exactly you have now and what you are trying to achieve? — Sergey Berezovskiy, Jul 17 '13 at 06:56

score 5 · Accepted Answer · answered Jul 17 '13 at 07:56

5

Your base class could depend on an interface (or other type) that's injected via the constructor. Your template method(s) could then use the methods on this interface/type to achieve the pattern's desired outcome:

public class BaseClass 
{
    IDependent _dependent;

    public BaseClass(IDependent dependent)
    {
         _dependent = dependent;
    }

    public void Alpha() {
        _depdendent.Beta();
    }

    public void Gamma() {
        _depdendent.Delta();
    }

}

Effectively using composition rather than inheritance.

answered Jul 17 '13 at 07:56

David Osborne

6,436
1
21
35

This solves half the problem. The other half is that I need to call BaseClass methods from the IDependent object. Can use another interface, but any ideas on a nicer solution? – Herman Schoenfeld Jul 17 '13 at 08:43
1

You could give the dependent a reference to the base class. Starts to get a little smelly though. OOD unease level is rising, suggesting this isn't the right solution... – David Osborne Jul 17 '13 at 09:33
I copied the MVP pattern (minus the 'Model') and made the 'View' class have events which it triggers. – Herman Schoenfeld Jul 17 '13 at 11:15
1

Sounds like a reasonable solution. – David Osborne Jul 17 '13 at 11:24

score 0 · Answer 2 · answered Dec 25 '17 at 10:53

You can achieve this by providing a reference to the base class on method call:

public ConcreteClass {
    public void Beta(BaseClass baseClass) {
        baseClass.Gamma();
    }

    public void Delta() {
        Console.WriteLine("Delta");
        }
}

Template method pattern without inheritance

2 Answers2