Do you use Template Method Pattern in programming languages with closures/delegates/function pointers ?

Question

I have been going back and forth between C# and Java for the last 8 years.

One thing that strikes me is that I have completely stopped using the "Template Method" design pattern in C#. Actually, in C# I Have come to think of this pattern as an anti-pattern.

http://en.wikipedia.org/wiki/Template_method_pattern

Coming back to Java, I find the pattern is alive and kicking. I still think it looks antique, but realise that there's no other way to do this in java. Java looks antique too ;)

Since this is going to come up anyway, Why is it an antipattern ?

• A lot of times it uses up your inheritance hierarchy for "the wrong reasons".
• Base classes have a tendency to become littered with all sorts of unerelated code.
• It forces you to lock down design, often quite early in the development process. (Premature lock down in a lot of cases)
• Changing this at a later stage becomes just harder and harder.

So with closures/delegates/function pointers, you normally pass around some function instead of subclassing.

So back to the question:

If your language has closures/delegates/function, do you use template method, and when ?

Answer 1

When I used Java, yes. But for languages with "closures/delegates/function", Lua in my case, no I don't anymore, instead I've been leaning more and more towards decoration pattern for most of my needs.

Answer 2

Yes, I use template method all the time, in the D programming language. Closures, delegates and function pointers are by their nature very loosely coupled to the base class. This is a good thing when you want this loose coupling. On the other hand, sometimes the behaviors you're customizing are by their nature very tightly coupled to the base class. Such behaviors would be useless in just about any other context. In cases where this coupling is necessary, the template method pattern is the cleanest, simplest way to express it.

A simple test is that you should always use strategy/closures/delegates/function pointers if communication between the base class and the customizable behavior is one-way, i.e. the base class calls the customizable behavior and that's it. If the customizable behavior needs a reference to the base class so it can invoke methods, etc., then the template method pattern is often the simplest way to proceed.

Answer 3

I'll add one more answer while I'm revisiting this thread:

The template method pattern is better than the strategy pattern when the policies you're customizing your base object with need to know about each other and can only make sense in a very limited subset of all possible combinations. For example, let's say your base class has a concrete function doIt(), and hooks beforeDoIt(), designed to allow the policies to initialize themselves and afterDoIt(), designed to allow the policies to clean up after themselves. You wouldn't want to set these behaviors independently because they only make sense when paired.