Come si può sapere se usare il modello composito o una struttura ad albero o una terza implementazione?

Ecco una semplice implementazione di "Gruppo" che ti permette di navigare verso il Root e navigare nell'albero di Root come collezione.

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;
      }
    }
  }
}

Quindi - dato un gruppo, puoi camminare su quell'albero del gruppo:

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

La mia speranza nel postare questo, è che mostrando come navigare in un albero (e dissipandone la complessità), potresti essere in grado di visualizzare le operazioni che vuoi eseguire sull'albero, e quindi rivisitare i modelli sul tuo proprio per vedere cosa si applica meglio.

Con la visione limitata che abbiamo dei requisiti di utilizzo o implementazione del tuo sistema è difficile diventare troppo specifici. Ad esempio, le cose che potrebbero venire in considerazione potrebbero essere:

• il sistema è altamente concorrente (molti utenti)?
• qual è il rapporto di lettura / scrittura dell'accesso ai dati? (alta lettura, scrittura bassa è comune)

Per quanto riguarda i pattern, ecc., mi preoccuperei meno di quali siano i pattern esatti nella tua soluzione e di più sulla progettazione della soluzione reale. Penso che la conoscenza dei modelli di progettazione sia utile, ma non l'essere tutto e il tutto alla fine: per usare un'analogia con lo scrittore, gli schemi di progettazione sono più come un dizionario di frasi comunemente viste, piuttosto che un dizionario di frasi che devi scrivere un intero libro da.

Il tuo diagramma sembra generalmente ok per me.

C'è un meccanismo che non hai menzionato e che ha una sorta di cache nella tua gerarchia. Ovviamente è necessario implementarlo con molta attenzione, ma potrebbe migliorare significativamente le prestazioni del sistema. Ecco una semplice descrizione (caveat emptor):

Per ciascun nodo della gerarchia, memorizzare i dati ereditati con il nodo. Fatelo pigramente o pro-attivamente, dipende da voi. Quando viene effettuato un aggiornamento della gerarchia, è possibile rigenerare i dati della cache per tutti i nodi interessati, quindi o impostare i flag "dirty" nelle posizioni appropriate e rigenerare pigramente i dati interessati quando necessario.

Non ho idea di quanto sia appropriato nel tuo sistema, ma potrebbe valerne la pena.

Inoltre, questa domanda su S.O. potrebbe essere rilevante:

link

So che è abbastanza ovvio, ma lo dirò comunque, Penso che dovresti dare un'occhiata al Observer Pattern che hai detto che hai un tipo di osservatore e quello che hai sembra un po 'come il modello di osservatore per me.

paio di link:

DoFactory

oodesign

controlla quelli fuori.  altrimenti mi limiterò a codificare ciò che si ha nel diagramma e quindi utilizzare il modello di progettazione per semplificare se necessario. sai già cosa deve accadere e come dovrebbe funzionare il programma. Scrivi un codice e vedi se è ancora adatto.