Raggruppamento di algoritmi concettuali in una classe o associati ai loro modelli di oggetti

Naviga le tue risposte
6

Se ho un numero di classi, diciamo una varietà di edifici di qualche tipo. Ognuno di questi edifici ha varie proprietà e alcune cose ecc.

Ora c'è una serie di operazioni che devo fare su questi edifici che sono tutti concettualmente uguali. Chiamiamo questo gruppo concettuale di operazioni Spostamento degli effluenti dell'edificio . Questa funzionalità è essenzialmente responsabile per l'esecuzione di metodi basati sulle informazioni di ogni edificio e quindi l'impostazione delle proprietà in altre aree del codice nonché l'impostazione di informazioni sull'edificio stesso (non può aiutare la necessità di impostare proprietà in altre aree al momento a causa delle attuali limitazioni di progettazione del sistema).

È importante notare che sebbene questi metodi siano concettualmente uguali e impostino molte delle stesse proprietà in varie classi, il modo in cui calcolano e ottengono questi valori sono diversi (condividono tuttavia un certo codice).

La mia domanda è se dovessi inserire il codice in una classe chiamata say EffluentBuildingDistribution o dovrei inserirlo in ogni classe della tua proprietà con metodi appropriati per eseguire essenzialmente lo stesso codice.

Quindi qualcosa del tipo: 

public class EffluentBuildingDistribution 
{
    public void DistributeEffluent()
    {
       // parameters example only
       DistributeBuildingHouse(var param1, var param2);
       DistributeBuildingDogHouse(var param1, var param2);
       DistributeBuildingSecondHouse(var param1, var param2);
    }

    // and various private methods to help work with the 3 methods some shared
    // others not    
}

o 

public class HouseBuilding    {
   public void DistributeEffluent(var param1, var param2)
   {
      // do stuff
   }
}

public class DogHouseBuilding    {
   public void DistributeEffluent(var param1, var param2)
   {
      // do stuff
   }
}

O forse nessuna di queste opzioni !.

Non sono sicuro se mettere il codice sugli oggetti su cui stanno lavorando sia la strada da percorrere, o metterla in una classe che rappresenta concettualmente ciò che stiamo cercando di fare. Questo è un esempio del mio attuale dilemma, ma è anche una domanda di responsabilità generale su dove proporzionare metodi e azioni ecc.

Se non è abbastanza specifico o ha bisogno di ulteriori spiegazioni, ecc. fammelo sapere e proverò a spiegare meglio il mio problema.

EDIT: A causa di una comprensibile confusione con il mio uso del termine Struttura nel mio esempio, da allora l'ho cambiato in Edificio . Alcune delle risposte riportate di seguito si riferiscono a Structure, ma sono comunque valide in quanto non ho modificato il nucleo della domanda.

    
posta dreza 26.02.2012 - 09:01
fonte

3 risposte

2

Che ne pensi di provare a crearne una versione generica? 

public class DistributeEffluent<T>
{
      public void DistributeEffluent()
      {
          // a generic algo working on T=HouseStructure as well as on T=DogHouseStructure... 
      }
}

Il modo in cui questo deve apparire esattamente dipende dal linguaggio di programmazione che stai usando (che hai dimenticato di menzionare, suppongo C # o Java?). Puoi realizzare questo anche usando il modello di metodo del modello , che è essenzialmente lo stesso approccio senza generici. La cosa che devi aggiungere qui è un'interfaccia comune o una classe base comune per le tue classi di struttura, quindi DistributeEffluent può funzionare con questa interfaccia. In questa interfaccia, dovrebbero esserci metodi elementari che implementano il comportamento individuale di ogni struttura, ma niente di più.

    
risposta data 26.02.2012 - 09:42
fonte
2

Non credo di averlo mai detto prima, ma questo sembra un candidato ideale per il pattern Visitor .

the visitor design pattern is a way of separating an algorithm from an object structure on which it operates

In sostanza, il pattern visitor consente di definire la struttura degli oggetti all'interno degli oggetti stessi (in un metodo accept), consentendo al contempo di inserire tutti i tuoi algoritmi nella classe Visitor (in una serie di metodi di visita, che può quindi condividere il codice con metodi privati). 

public class StructureVisitor
{
    public void visit (StructureHouse structure)
    {
        // do stuff to house here
    }

    public void visit (StructureDogHouse structure)
    {
        // do stuff to dog house here
    }

    public void visit (StructureSecondHouse structure)
    {
         // do stuff to second house here
    }
}

E poi hai una classe genitore che ha un metodo di accettazione un po 'come questo: 

public void accept (StructureVisitor visitor)
{
    this.House.accept(visitor);
    this.DogHouse.accept(visitor);
    this.SecondHouse.accept(visitor);
}

Ciascuno dei metodi accettati sopra passerebbe semplicemente alla classe del visitatore (a meno che non ci fosse più profondità nella struttura, ovviamente). 

public void accept (StructureVisitor visitor)
{
    visitor.visit(this);
}
    
risposta data 26.02.2012 - 14:26
fonte
2

Probabilmente creerei un'interfaccia DistributeEffluent e una o più implementazioni di esso. Quindi, vorrei creare un membro dell'interfaccia nelle classi della struttura per poter utilizzare le operazioni.

Dai un'occhiata a l'articolo di Wikipedia sui Modelli di strategia.

    
risposta data 26.02.2012 - 09:46
fonte

Leggi altre domande sui tag

Il sapore di Python delle espressioni regolari - in relazione a quale? Linguaggio che può garantire staticamente che i campi di una mappa siano presenti