Pattern Pattern GoF: quali usi effettivamente? [chiuso]

Ecco un elenco di quelli che ho usato o visto in pratica:

Singleton - L'oggetto Application in ASP.Net ne è un primo esempio.

Adapter - La connessione ai database di solito può coinvolgere una classe Adapter almeno nella mia area di .Net.

Factory - Generale per la generazione di oggetti anche se l'ho visto di più in alcuni vecchi ASP classici nel corso della giornata.

Strategia - Avevo un'applicazione che per ogni tipo di dispositivo avevo una struttura simile per la classe che considererei un'implementazione di questo modello.

Facciata - In un certo senso questo è simile al pattern dell'adapter in termini di qualcosa che lega di solito un paio di sistemi.

Gli autori hanno compilato i modelli dei progetti osservati che hanno trovato nelle applicazioni reali. Probabilmente nessuno li utilizzerà tutti, ma sono tutti usati.

Decoratore .

EDIT : in quasi tutti i progetti che vanno oltre la fase "banale", uno finisce con un'interfaccia IAction (i dettagli possono essere diversi):

// Programming Language does not matter
interface IAction {
     bool operateOn(Foo* target);
     string getDisplayName(); // useful for debugging and logging
};

L'ora successiva trascorro scrivendo un sacco di classi piccole, quasi banali che implementano IAction. Se combinati, sono molto potenti e flessibili.

es. un LogAction (scrive per registrare ed eseguire l'IAction), NullAction (non fa nulla e restituisce true), ActionList (esegue un elenco di IActions e restituisce l'ANDing dei bool). In alcuni casi un AndAction (restituisce l'AND-ing di due azioni, potrebbe essere cortocircuitato o meno), OrAction , NotAction ha anche un senso.

Sebbene tecnicamente dagli esempi precedenti solo LogAction sia un Decorator (l'altro non funziona esattamente su 1 IAction), considero questa una generalizzazione del pattern Decorator quando creo una ActionList di LogActions of IActions.

Suppongo che intendi limitare la domanda all'uso dei pattern nei propri codici / progetti (nessuna libreria di classi e framework di terze parti).

Come altri, ho usato anche i pattern Factory più spesso. Quindi

• Singleton : non tanto al giorno d'oggi, ma a volte è necessario, in genere per i dati di configurazione globali
• Strategia e Metodo modello : abbastanza spesso, ad es. per rappresentare diversi tipi di calcoli nella nostra app
• Builder : per il marshalling dei risultati delle transazioni con un sistema mainframe in oggetti di output (in alcuni casi include una grande quantità di analisi del testo e creazione di gerarchie di oggetti di grandi dimensioni)
• Comando : l'ho implementato solo una volta molti anni fa, ma oggigiorno nel nostro progetto Java uso Callables di tanto in tanto, che credo siano fondamentalmente comandi

Ho usato molti degli altri che sono già stati menzionati (Singleton, Factory, Builder, Command, Strategy, ecc ...)

Uno che non ho ancora visto menzionato è il Flyweight, che tendo ad usare molto. Ho fornito un'implementazione di esempio di seguito:

/**
 * Flyweight class representing OCR digits.
 * 
 * @author matt
 *
 */
public class Digit {
    /** Static flyweight map containing Digits which have been encountered. **/
    private static Map digits = new HashMap();

    /** The block of text representing Digit. **/
    private String blockRep = null;

    /** A map representing acceptable blocks of characters and the string representation of their
     * numerical equivalents.
     */
    public static final Map VALID_DIGITS;

    /** Enum of valid digits. **/
    public static enum DigitRep {
        ZERO    (   " _ \n" +
                    "| |\n" +
                    "|_|"       ),

        ONE (       "   \n" +
                    "  |\n" +
                    "  |"       ),

        TWO (       " _ \n" +
                    " _|\n" +
                    "|_ "       ),

        THREE   (   " _ \n" +
                    " _|\n" +
                    " _|"       ),

        FOUR    (   "   \n" +
                    "|_|\n" +
                    "  |"       ),

        FIVE    (   " _ \n" +
                    "|_ \n" +
                    " _|"       ),

        SIX     (   " _ \n" +
                    "|_ \n" +
                    "|_|"       ),

        SEVEN   (   " _ \n" +
                    "  |\n" +
                    "  |"       ),

        EIGHT   (   " _ \n" +
                    "|_|\n" +
                    "|_|"       ),

        NINE    (   " _ \n" +
                    "|_|\n" +
                    " _|"       );

        private String blockRep;

        DigitRep(String blockRep) {
            this.blockRep = blockRep;
        }

        @Override
        public String toString() {
            return blockRep;
        }
    }

    static {
        /* Initialize the map of acceptable character blocks. */
        Map tmpMap = new HashMap();
        tmpMap.put( DigitRep.ZERO.toString(),   "0");
        tmpMap.put( DigitRep.ONE.toString(),    "1");
        tmpMap.put( DigitRep.TWO.toString(),    "2");
        tmpMap.put( DigitRep.THREE.toString(),  "3");
        tmpMap.put( DigitRep.FOUR.toString(),   "4");
        tmpMap.put( DigitRep.FIVE.toString(),   "5");
        tmpMap.put( DigitRep.SIX.toString(),    "6");
        tmpMap.put( DigitRep.SEVEN.toString(),  "7");
        tmpMap.put( DigitRep.EIGHT.toString(),  "8");
        tmpMap.put( DigitRep.NINE.toString(),   "9");       
        VALID_DIGITS = Collections.unmodifiableMap(tmpMap);
    }

    /**
     * Private constructor to enforce flyweight/factory pattern.
     * 
     * @param blockRep
     */
    private Digit(String blockRep) {
        this.blockRep = blockRep;
    }

    /**
     * Flyweight factory method to create a Digit object from the "block"
     * representation of the digit.
     * @param blockRep The "block" representation of a digit.  Should look
     * something like:
     * " _ \n"
     * "|_|\n"
     * "|_|"
     * @return A flyweight Digit object representing the digit.
     */
    public static synchronized Digit getDigit(String blockRep) {
        Digit digit = digits.get(blockRep);
        if(digit == null) {
            digit = new Digit(blockRep);
            digits.put(blockRep, digit);
        }

        return digit;
    }

    /**
     * Determines whether or not the digit is valid.
     * @return true if the digit is valid, else false.
     */
    public boolean isValid() {
        return VALID_DIGITS.containsKey(blockRep);
    }

    /**
     * Accessor method to get the block representation of this digit.
     * 
     * @return
     */
    public String getBlockRep() {
        return blockRep;
    }

    @Override
    public String toString() {
        return VALID_DIGITS.containsKey(blockRep) ? VALID_DIGITS.get(blockRep) : "?";
    }
}

La maggior parte dei modelli Gang of Four originali sono ancora usati oggi, ma ce ne sono altri ora popolari che non sono nel libro.

Trova un riferimento per Design Patters nella lingua che usi. Tendono ad essere più concreti e utilizzano caratteristiche linguistiche specifiche per implementare gli schemi in un modo più succinto ed elegante.

Tre grandi risorse per i modelli di progettazione:

Il libro "Head First Design Patterns" - la lingua prescelta è Java, ma è rilevante per tutte le lingue . Modelli di progettazione dofactory - ottime e gratuite spiegazioni di modelli di design .net con codice. PluralSight - Design Patterns Library - questo è pagato, ma è troppo buono no per includerlo nell'elenco.

Bene, se usi librerie comuni come ACE, finisci per usare più di quanto pensi di usare. Io uso Observer / Observable estesamente: -)

Ho usato un Builder almeno una volta (lo stesso processo di conversione potrebbe generare output HTML o Excel).

Uso frequentemente il metodo Template (per attività correlate a JDBC o controller Swing astratti).

Una volta ho dovuto sviluppare molte nuove funzionalità in un'applicazione basata su moduli, il che era un disastro. Ho potuto progredire solo dopo aver refactorato le cose esistenti in una soluzione basata sullo stato. (Bene, la maggior parte).

Uso anche i comandi di frequente (azioni di oscillazione) e anche gli osservatori.

Una volta ho usato una soluzione tipo Mememento per rilevare i cambiamenti nei moduli Swing. La forma sarebbe serializza il suo stato che ho confrontato (uguale a ()) con gli stati precedenti.

Credo di averne quasi tutti la mia carriera. l'unico che sono sicuro di non aver utilizzato è quello Adaptor Pattern implementato con ereditarietà multipla sul libro poiché non sono un grande fan dell'ereditarietà multipla.

Sono appassionato di Decorator. L'unico che ho aggiunto a quelli menzionati è Proxy.