Come determinare il design migliore?

Question

Come determinare il design migliore?

#1 da (6 voti)
#2 da (1 voti)

1

Che cosa devo considerare per determinare quale disegno scelgo quando ho lo scenario seguente?

Ci sono due casi da considerare;

Data T una classe generica, devo fare qualcosa con più T (Iterating each one of them).
In altri casi, con lo stesso T, devo elaborare solo una volta.

In entrambi i casi, indipendentemente da ciò che è T e da come avrò bisogno di elaborarlo, la classe che comprende T si comporterà esattamente nello stesso modo, quindi, non devo preoccuparmi dei dettagli di implementazione.

Ci sono 2 possibili soluzioni e non so quali indicazioni dovrei seguire per decidere tra di loro.

Considerare sempre come lista, questo è per semplicità, dal momento che non ci sono differenze tra un elenco di T e solo T.
Utilizzare l'ereditarietà; la prima classe figlio riceverà una lista di T e lavorerà con essa, la seconda, una singola T e lavorerà con essa.

Ci sono buone pratiche o qualche articolo per aiutare a decidere questi casi? Sto cercando qualcosa come questo articolo , o il tuo esperienza pure.

UPDATE:

La classe che sto progettando non è T, ma è il suo compositore.

design architecture

posta EProgrammerNotFound 20.01.2014 - 12:15

fonte

2 risposte

1

Se solo i singoli elementi T sono in fase di elaborazione, senza alcuna relazione reciproca, creerei solo una singola classe che funzioni su un singolo T. Ciò mantiene quella classe il più semplice possibile. L'iterazione su più Ts e l'applicazione dell'azione su ognuno di essi può essere responsabilità di qualche altra classe. In questo modo non c'è motivo di creare un oggetto lista quando si lavora su un singolo oggetto, né ci sono più classi che fondamentalmente fanno la stessa cosa.

risposta data 20.01.2014 - 12:35

fonte

Leggi altre domande sui tag design architecture

Gara contro requisiti e progettazione della soluzione Come creare un prototipo di metodo Python

score 6 · Accepted Answer

Se l'elaborazione di ogni istanza di T è indipendente dall'elaborazione degli altri, vorrei solo creare una classe che elabora un T e quindi avvolgerla con una classe che "lo alimenta" con una sequenza di T s e chiama semplicemente la prima classe in una sorta di blocco foreach .

Non userei l'ereditarietà per quello.

Esempio semplificato (C #):

interface IFoo
{
    void DoStuff();
}

class FooProcessor<T> where T : IFoo
{
    public void Process(T item)
    {
        item.DoStuff();
    }
}

class MultipleFooProcessor<T> where T : IFoo
{
    // composition over inheritance - MultipleFooProcessor does not share any "genes" with FooProcessor, 
    // it just keeps an instance of it in a private field
    FooProcessor<T> processor;

    // we're passing a regular FooProcessor here. 
    // thanks to not using inheritance, we could eg. create an IFooProcessor interface
    // and pass a different implementation of IFooProcessor here, allowing for a more flexible design.
    // see: dependency injection, loose coupling
    public MultipleFooProcessor(FooProcessor<T> processor)
    {
        this.processor = processor;
    }

    public void Process(IEnumerable<T> sequence)
    {
        foreach (T item in sequence)
        {
            Process(item);
        }
    }

    public void Process(T item)
    {
        processor.Process(item);
    }
}