Strategy pattern
Nella programmazione ad oggetti, lo Strategy pattern è uno dei pattern fondamentali, definiti originariamente dalla gang of four.
Lo Strategy pattern è uno dei pattern comportamentali. L'obiettivo di questa architettura è isolare un algoritmo all'interno di un oggetto. Il pattern Strategy è utile in quelle situazioni dove sia necessario modificare dinamicamente gli algoritmi utilizzati da un'applicazione. Si pensi ad esempio alle possibili visite in una struttura ad albero (visita anticipata, simmetrica, posticipata): mediante il pattern Strategy è possibile selezionare a tempo di esecuzione una tra le visite ed eseguirla sull'albero per ottenere il risultato voluto. Il design pattern Iterator si basa proprio su questo.
Questo pattern prevede che gli algoritmi siano intercambiabili tra loro (in base ad una qualche condizione) in modo trasparente al client che ne fa uso. In altre parole: la famiglia di algoritmi che implementa una funzionalità (ad esempio di visita o di ordinamento) esporta sempre la medesima interfaccia, in questo modo il client dell'algoritmo non deve fare nessuna assunzione su quale sia la strategia istanziata in un particolare istante.
Struttura
Esempio
//classe concreta
class Document
{
private string title;
private string codice;
public Document(string title, string codice)
{
this.title = title;
this.codice = codice;
}
public string Title
{
get { return title; }
}
public string Codice
{
get { return codice; }
}
}
class SortedDocumentList
{
private List<Document> documentList = new List<Document>();
private ISortStrategy sortstrategy;
public ISortStrategy SortStrategy
{
set
{
this.sortstrategy = value;
}
}
public void Add(Document document)
{
documentList.Add(document);
}
public void Sort()
{
sortstrategy.Sort(documentList);
// Display results
foreach (Document document in documentList)
{
Console.WriteLine(string.Format(" {0}",document.Title));
}
Console.WriteLine();
}
}
// "Strategy"
interface ISortStrategy
{
void Sort(List<Document> documentList);
}
// "classe concreta Strategy"
class QuickDocumentSort : ISortStrategy
{
public void Sort(List<Document> documentList)
{
// Call overloaded Sort
Sort(documentList, 0, documentList.Count - 1);
Console.WriteLine("QuickSorted list ");
}
// Recursively sort
private void Sort(List<Document> list, int left, int right)
{
int lhold = left;
int rhold = right;
// Use a random pivot
Random random = new Random();
int pivot = random.Next(left, right);
Swap(list, pivot, left);
pivot = left;
left++;
while (right >= left)
{
int compareleft = list[left].Title.CompareTo(list[pivot].Title);
int compareright = list[right].Title.CompareTo(list[pivot].Title);
if ((compareleft >= 0) && (compareright < 0))
{
Swap(list, left, right);
}
else
{
if (compareleft >= 0)
{
right--;
}
else
{
if (compareright < 0)
{
left++;
}
else
{
right--;
left++;
}
}
}
}
Swap(list, pivot, right);
pivot = right;
if (pivot > lhold) Sort(list, lhold, pivot);
if (rhold > pivot + 1) Sort(list, pivot + 1, rhold);
}
// Swap helper function
private void Swap(List<Document> list, int left, int right)
{
Document temp = list[right];
list[right] = list[left];
list[left] = temp;
}
}
Considerazioni
Voci correlate
Bibliografia
- Gamma, E., Helm, R., Johnson, R. e Vlissides, J., Design Patterns: elementi per il riuso di software a oggetti, Addison Wesley, 1995, ISBN 88-7192-150-X
- Originale: Design Patterns: Elements of Reusable Object-Oriented Software, Addison Wesley, 1995, ISBN 0-201-63361-2
Altri progetti
Wikimedia Commons contiene immagini o altri file su Strategy pattern
