Wie kann ich mit so vielen logischen/verknüpften Feldern umgehen (ein bisschen lang)?

Question

Ich entwerfe eine Datenvisualisierungsklasse: Bei einem Datenobjekt wird eine visuelle Darstellung auf dem Bildschirm des Benutzers erstellt.

Ich habe ein paar Design-Einschränkungen muss ich einhalten:

1. Die Klasse ist eine parameter „Visualize“ Methode zu haben. Alle Visualisierungseinstellungen sollen Instanzfelder sein.
2. Der Zustand der Klasse sollte immer genau sein.

Zur Veranschaulichung:

public class DataVisualizer { 

    public DataObject Object { get { return _object; } set { // logic } } 

    public void Visualize(){ 
     // visualize the data... 
    } 
} 

So weit so gut, aber die Klasse ist auch eine "DataObjectCollection" Feldinstanz zu haben. Es ist nicht notwendig, dass das oben genannte Feld gesetzt wird, um das Datenobjekt zu visualisieren, aber wenn dies der Fall ist, werden zusätzliche Methoden wie "VisualizeNext" und "VisualizePrevious" aktiviert (die den Status des Visualizers ändern und Visualize aufrufen müssen). .

Zur Veranschaulichung:

public class DataVisualizer { 

    public DataObjectCollection { get { return _dataObjectCollection; set { // logic } } 
    public DataObject Object { get { return _object; } set { // logic } } 

    public void Visualize(){ 
     // visualize the data... 
    } 

    public void VisualizeNext(){ 
     Object = NextObjectInDataObjectCollection(); 
     Visualize(); 
    } 

    public void VisualizePrevious(){ 
     Object = PreviousObjectInDataObjectCollection(); 
     Visualize(); 
    } 
} 

Jetzt Design Einschränkung # 2 oben erinnern. Um ein Beispiel zu geben, wenn der Benutzer DataObjectCollection während der Einstellung setzt, müssen wir überprüfen, was DataObject ist. Wenn DataObject nicht in DataObjectCollection enthalten ist, müssen Sie DataObject entweder auf null oder auf das erste Element in DataObjectCollection setzen. Auf der anderen Seite müssen wir, wenn wir DataObject setzen, prüfen, ob DataObjectCollection DataObject enthält. Wenn nicht, müssen wir DataObjectCollection auf null setzen.

Um die Dinge komplizierter zu machen, muss ich auch den Index des Datenobjekts verfolgen, das für die VisualizeNext/Previous-Methode visualisiert wird. -1 für wenn die Sammlung null ist. (Ich kann IndexOf nicht verwenden, da die Auflistung doppelte Elemente oder Nullwerte enthalten könnte.)

Und zu allem Übel ist die DataObjectCollection tatsächlich Teil einer anderen Sammlung! Also im Grunde, unsere Visualizer sieht ungefähr so ​​aus:

public class DataVisualizer { 

    public DataObjectOuterCollection { get { return _dataObjectOuterCollection; set { // logic } } 
    public DataObjectInnerCollection { get { return _dataObjectInnerCollection; set { // logic } } 
    public DataObject Object { get { return _object; } set { // logic } } 

    public void Visualize(){ 
     // visualize the data... 
    } 

    public void VisualizeNext(){ 
     Object = NextObjectInDataObjectCollection(); 
     Visualize(); 
    } 

    public void VisualizePrevious(){ 
     Object = PreviousObjectInDataObjectCollection(); 
     Visualize(); 
    } 
} 

Remembering Punkt 2 oben, werden die Dinge kompliziert, weil jedes Mal ein Feld gesetzt ist, muss ich den Wert der anderen Felder überprüfen, und stellen Sie sie auf die richtige Werte. Wenn InnerCollection beispielsweise nicht in OuterCollection enthalten ist, muss InnerConnection auf das erste Element von OuterCollection oder null festgelegt werden, und dasselbe gilt für DataObject. Ich muss auch den Index von InnerCollection mitverfolgen!

Gibt es ein Entwurfsmuster oder eine Code-Struktur, die ich befolgen kann, um die Handhabung von so viel Logik zu erleichtern? Wenn ein Feld nur mit einem anderen Feld "verbunden" ist, ist es einfach, aber wenn es 5 davon ist, wird es schnell viel zu verwalten!

Answer 1

Es klingt wie Sie brauchen ein paar separate Klassen, je nachdem, woher die Daten stammen. Sie alle können eine einzige Schnittstelle implementieren, wie folgt aus:

public interface IDataVisualizer 
{ 
    void Visualize(); 
} 

Auf diese Weise können Sie die Regeln der Sammlung basierten Visualizer aufgeteilt und die einzelnen Artikel basiert Visualizer in getrennte Klassen.

public class CollectionVisualizer : IDataVisualizer 
{ 
    List<DataObject> objects; 
    int index; 

    void Visualize() { ... } 
    void VisualizeNext() { ... } 
    void VisualizePrevious() { ... } 
} 

---

public class SingleObjectVisualizer : IDataVisualizer 
{ 
    DataObject object; 

    void Visualize() { ... } 
} 

Nun scheinen die Einschränkungen etwas einfacher zu verwalten.