Im working on a project at the moment building a message bus using WCF. We have a submit data method that takes a number of different message types; create widget, update widget etc. We need to process these requests quite differently based on the type of message passed in but there is some commonality to the processing for all message types.
The template method pattern was really useful here, we have a base message processor that contains the common processing steps and provides a "hook" method that specific message processor sub classes can override. This base class takes care of common logic for us like storing the message payload for audit and saving any results from processing. The code looks like this:
public abstract MessageProcessorBase<TMessage>
{
public void ProcessMessage(TMessage message)
{
StoreMessage(message);
ProcessingResults results = ProcessMessageByType();
SaveProcessingResults(results);
}
protected abstract ProcessingResults ProcessMessageByType();
private void StoreMessage(TMessage)
{
...
{
private void SaveProcessingResults(ProcessingResults results)
{
...
}
}
All of these methods are private on the MessageProcessorBase except the ProceessMessageByType which is abstract and overridden in the subtypes. Now for each message type we simply create a message processor and implement the specific processing logic.
The message processor base is generic meaning it can be strongly typed to each specific message type, while not being tied to any one message type. The nice thing about this is that we have a strongly typed message processor for each message type.
That's all there is to it, a tidy way of using inheritence to make our message processor class closed to change but open to extension.