Wie können Sie feststellen, ob Sie ein zusammengesetztes Muster, eine Baumstruktur oder eine dritte Implementierung verwenden sollen?

Ich habe zwei Client-Typen, einen " Observer " -Typ und einen " Subject " -Typ. Sie sind beide einer Hierarchie von Gruppen zugeordnet .

Der Beobachter erhält (Kalender-) Daten von den Gruppen, denen er in den verschiedenen Hierarchien zugeordnet ist. Diese Daten werden berechnet, indem Daten aus übergeordneten Gruppen der Gruppe kombiniert werden, die versuchen, Daten zu sammeln (jede Gruppe kann nur einen übergeordneten Benutzer haben ).

Der Betreff kann die Daten (die die Beobachter erhalten) in den Gruppen erstellen, denen er zugeordnet ist. Wenn Daten in einer Gruppe erstellt werden, verfügen auch alle "Kinder" der Gruppe über die Daten, und sie können eine eigene Version eines bestimmten Datenbereichs erstellen , die jedoch weiterhin mit den ursprünglich erstellten Daten verknüpft ist (in In meiner spezifischen Implementierung enthalten die Originaldaten Zeiträume und Überschriften, während die Untergruppen den Rest der Daten für die Empfänger angeben, die direkt mit ihren jeweiligen Gruppen verknüpft sind.

Wenn das Subjekt Daten erstellt, muss es jedoch prüfen, ob alle betroffenen Beobachter Daten haben, die im Widerspruch dazu stehen, was meines Wissens nach eine riesige rekursive Funktion bedeutet.

Ich denke, das lässt sich so zusammenfassen , dass ich in der Lage sein muss, eine Hierarchie zu haben , in der man auf und ab gehen kann , und dass einige Orte sie als Ganzes behandeln können (Rekursion, im Grunde genommen).

Außerdem strebe ich nicht nur eine Lösung an, die funktioniert. Ich hoffe, eine Lösung zu finden, die relativ einfach zu verstehen ist (zumindest in Bezug auf die Architektur) und auch flexibel genug, um in Zukunft problemlos zusätzliche Funktionen zu erhalten.

Gibt es ein Entwurfsmuster oder eine bewährte Methode, um dieses Problem oder ähnliche Hierarchieprobleme zu lösen?

EDIT :

Hier ist das Design, das ich habe:

Die "Phoenix" -Klasse heißt so, weil mir noch kein passender Name eingefallen ist.

Aber außerdem muss ich in der Lage sein, bestimmte Aktivitäten für bestimmte Beobachter zu verbergen , obwohl sie über die Gruppen mit ihnen verbunden sind.

Ein wenig Off-Topic :

Ich persönlich bin der Meinung, dass ich dieses Problem auf kleinere Probleme reduzieren sollte, aber es entgeht mir, wie. Ich denke, das liegt daran, dass mehrere rekursive Funktionen, die nicht miteinander verknüpft sind, und verschiedene Client-Typen beteiligt sind, die Informationen auf unterschiedliche Weise abrufen müssen. Ich kann meinen Kopf nicht wirklich darum wickeln. Wenn jemand mich in eine Richtung leiten kann, wie ich Hierarchieprobleme besser einkapseln kann, würde ich mich sehr darüber freuen.

Hier ist eine einfache "Gruppen" -Implementierung, mit der Sie zum Stamm navigieren und den Stamm als Sammlung durchsuchen können.

public class Group
{
  public Group Parent
  public List<Group> Children

  public IEnumerable<Group> Parents()
  {
    Group result = this;
    while (result.Parent != null)
    {
      result = result.Parent;
      yield return result;
    }
  }
  public Group Root()
  {
    return Parents.LastOrDefault() ?? this;
  }


  public IEnumerable<Group> WalkTreeBreadthFirst(
  {
    //http://en.wikipedia.org/wiki/Breadth-first_search
    HashSet<Group> seenIt = new HashSet<Group>()
    Queue<Group> toVisit = new Queue<Group>();
    toVisit.Enqueue(this);

    while (toVisit.Any())
    {
      Group item = toVisit.Dequeue();
      if (!seenIt.Contains(item))
      {
        seenIt.Add(item);
        foreach (Group child in item.Children)
        {
          toVisit.Enqueue(child);
        }
        yield return item;
      }
    }
  }

  public static IEnumerable<Group> WalkTreeDepthFirst()
  {
    // http://en.wikipedia.org/wiki/Depth-first_search
    HashSet<Group> seenIt = new HashSet<Group>();
    Stack<Group> toVisit = new Stack<Group>();

    toVisit.Push(this);

    while (toVisit.Any())
    {
      Group item = toVisit.Pop();
      if (!seenIt.Contains(item))
      {
        seenIt.Add(item);
        foreach (Group child in item.Children.Reverse())
        {
          toVisit.Push(child);
        }
        yield return item;
      }
    }
  }
}

Wenn Sie also eine Gruppe haben, können Sie den Baum dieser Gruppe gehen:

Group myGroup = GetGroup();
Group root = myGroup.Root;
foreach(Group inTree in root.WalkTreeBreadthFirst())
{
  //do something with inTree Group.
}

Ich hoffe, dass Sie beim Posten dieses Dokuments zeigen können, wie Sie in einem Baum navigieren (und dessen Komplexität beseitigen), dass Sie in der Lage sind, die Vorgänge zu visualisieren, die Sie an dem Baum ausführen möchten, und die Muster dann selbst überprüfen, um sie anzuzeigen was am besten gilt.

Aufgrund der eingeschränkten Sicht auf die Nutzungs- oder Implementierungsanforderungen Ihres Systems ist es schwierig, zu spezifisch zu werden. Zum Beispiel könnten folgende Dinge in Betracht kommen:

• Ist das System sehr zeitgleich (viele Benutzer)?
• Wie ist das Lese- / Schreibverhältnis beim Datenzugriff? (High Read, Low Write ist üblich)

Bei Mustern usw. würde ich mich weniger darum kümmern, welche genauen Muster in Ihrer Lösung auftreten, sondern vielmehr um das Design der tatsächlichen Lösung. Ich halte Kenntnisse über Entwurfsmuster für nützlich, aber nicht für das A und O: Um eine Schriftstelleranalogie zu verwenden, sind Entwurfsmuster eher ein Wörterbuch häufig verwendeter Phrasen als ein Wörterbuch von Sätzen, in dem Sie ein ganzes Buch schreiben müssen von.

Ihr Diagramm sieht für mich im Allgemeinen in Ordnung aus.

Es gibt einen Mechanismus, den Sie nicht erwähnt haben und der darin besteht, eine Art Cache in Ihrer Hierarchie zu haben. Natürlich müssen Sie dies mit großer Sorgfalt umsetzen, aber es könnte die Leistung Ihres Systems erheblich verbessern. Hier ist eine einfache Einstellung (Vorbehalt Emptor):

Speichern Sie für jeden Knoten in Ihrer Hierarchie geerbte Daten mit dem Knoten. Tun Sie dies faul oder proaktiv, das liegt an Ihnen. Wenn die Hierarchie aktualisiert wird, können Sie entweder die Cache-Daten für alle betroffenen Knoten dort und danach neu generieren oder an den entsprechenden Stellen "Dirty" -Flags setzen und die betroffenen Daten bei Bedarf träge neu generieren.

Ich habe keine Ahnung, wie angemessen dies in Ihrem System ist, kann aber eine Überlegung wert sein.

Auch diese Frage zu SO kann relevant sein:

/programming/1567935/how-to-do-inheritance-modeling-in-relational-databases

Ich weiß, dass dies ein bisschen offensichtlich ist, aber ich werde es trotzdem sagen. Ich denke, Sie sollten einen Blick darauf werfen Observer Pattern , dass Sie erwähnt haben, dass Sie einen Beobachter-Typ haben, und was Sie haben, sieht für mich wie das Beobachter-Muster aus.

ein paar links:

DoFactory

oodesign

check die aus. Andernfalls würde ich einfach das, was Sie in Ihrem Diagramm haben, codieren und dann das Entwurfsmuster verwenden, um es bei Bedarf zu vereinfachen. Sie wissen bereits, was passieren muss und wie das Programm funktionieren soll. Schreiben Sie einen Code und prüfen Sie, ob er noch passt.