Pattern Template Method

Summary Un design pattern che definisce un algoritmo e permette alla classe derivata di ridefinire alcuni passi.

Conosciuto anche come

Non ha altri nomi.

Intento

Il design pattern Template Method definisce lo scheletro di un algoritmo (nel metodo TemplateMethod di AbstractClass) e delega ad una classe derivata (ConcreteClass) la possibilità di ridefinire alcuni passi (PrimitiveOperation1, PrimitiveOperation2, ...) dell'algoritmo (nel metodo TemplateMethod) senza bisogno di modificare l'intero algoritmo o la sua struttura.

Il passo dell'algoritmo viene ridefinito attraverso l'ereditarietà a design-time quindi questo design pattern è classificato rispetto allo scopo (vedi ClassificazioneDeiDesignPattern#ClassiOggetti) come rivolto alle classi. Rispetto al fine questo design pattern è classificato tra i ClassificazioneDeiDesignPattern#Comportamentali.

Diagramma UML

Un'altro diagramma equivalente qui .

Motivazione

Puo capitare che più classi (ConcreteClass) abbiano parti di codice uguale per un metodo , il design pattern Template Method permette di definire una classe base (AbstractClass) con un template method (il metodo TemplateMethod) in cui inserire il codice comune lasciando ad ogni sotto classe (ConcreteClass) di indicare la propria parte di codice personalizzato (facendo l'override di PrimitiveOperation1, PrimitiveOperation2, ...).

Nelle librerie il design pattern Template Method può essere usato per fornire funzionalità invarianti e riutilizzabili (nel metodo TemplateMethod di una AbstractClass) lasciando agli utilizzatori della libreria la possibilità di definire le parti che possono variare (facendo l'override di PrimitiveOperation1, PrimitiveOperation2, ...).

Esempi d'uso in .NET

Un esempio d'uso di questo desin pattern in .NET è il WebControl (AbstractClass) il cui metodo Render (TemplateMethod) definisce l'algoritmo con questi passi:

        this.RenderBeginTag(writer); // PrimitiveOperation1
        this.RenderContents(writer); // PrimitiveOperation2
        this.RenderEndTag(writer);   // PrimitiveOperation3

di cui una classe derivata (ConcreteClass) può farne l'override per personalizzare il singolo passo.

Note sulla implementazione in .NET

In C++ è possibile fare una implementazione più pulita di questo design pattern perché rende possibile marcare le "PrimitiveOperation" contemporaneamente come private e virtual rendendo esplicito il fatto che hanno il solo scopo di essere richiamate dal metodo TemplateMethod e non direttamente dalla interfaccia pubblica o protected. In .NET e C# invece un metodo virtual deve essere almeno protected.

Del codice .NET di esempio è disponibile qui .

Relazione con altri design pattern

Il FactoryMethod del PatternFactoryMethod viene spesso chiamato dal TemplateMethod di questo design pattern.

Vedi anche i DesignPatternSimmetrici e il RefactoringFormTemplateMethod.

Vedi la mappa della RelazioneTraDesignPattern.

Approfondimenti

Questo design pattern viene usato per avere un controllo fine delle estensioni che le classi derivate possono fare alla classe base infatti permette di indicare i singoli passi di una operazione che possono essere ridefiniti o meno dalla classe base. E' un pattern così fondamentale che si ritrova in quasi ogni classe astratta.

Domande di approfondimento

Questo design pattern di basa sulla sulla ereditarietà, sarebbe possibile avere la stessa funzionalità usando invece la composizione (ossia una RelazioneDiContenimento verso un oggetto che implementa la personalizzazione di una "PrimitiveOperation")? Cosa cambia facendo in questo caso?
Che differenze ci sono tra questo design pattern e il PatternStrategy?

Link

VediAnche CatalogoDeiDesignPattern