Codice C # per associazione, aggregazione, composizione

Sto cercando di confermare la mia comprensione di come sarebbe il codice per associazione, aggregazione e composizione. Quindi qui va ..

Aggregazione : Has-a. Ha un object esistente di un altro tipo

public class Aggregation { SomeUtilityClass objSC public void doSomething(SomeUtilityClass obj) { objSC = obj; } } 

Composizione : è composta da un altro object

 public class Composition { SomeUtilityClass objSC = new SomeUtilityClass(); public void doSomething() { objSC.someMethod(); } } 

Associazione : ho due punti di vista su questo.

  1. Quando una class è associata a un’altra. Quindi entrambi i precedenti sono esempi di associazione.
  2. L’associazione è una forma più debole di aggregazione in cui la class non mantiene un riferimento all’object che riceve.

     public class Association { //SomeUtilityClass objSC /*NO local reference maintained */ public void doSomething(SomeUtilityClass obj) { obj.DoSomething(); } } 

La mia comprensione è corretta? Ho letto articoli in conflitto qui e qui e quindi non sono sicuro di quale seguire. La mia comprensione sembra essere in linea con il primo link. Sento che il secondo link è sbagliato, o forse forse non l’ho capito bene.

Cosa ne pensi?

La differenza tra aggregazione e composizione è piuttosto sfocata e AFAIK si riferisce all’esistenza logica degli oggetti “figli” dopo che il contenitore è stato distrutto. Quindi, nel caso dell’aggregazione, gli oggetti all’interno del contenitore possono ancora esistere dopo che l’object contenitore è stato distrutto, mentre nel caso della progettazione della composizione richiede che vengano distrutti. Alcune analogie:

  • Un object Car contenente quattro oggetti Wheel . Normalmente se distruggete la macchina (chiamando un metodo per ripulirla) dovreste anche distruggere le ruote nel processo, poiché non ha molto senso che esistano fuori dalla macchina (a meno che non le spostiate su un altro object Car ). Più realisticamente, un object lettore che avvolge un stream di input chiuderà anche il stream interno quando viene chiuso. Questa è la composizione .
  • Un object Person contiene (possiede) un object Radio . Se la Person muore, la Radio può essere ereditata da un’altra Person vale a dire che ha senso esistere senza il proprietario originale. Più realisticamente, un elenco contenente oggetti non richiede che tutti gli oggetti vengano disposti quando l’elenco stesso è disposto. Questa è l’ aggregazione .

Edit : Dopo aver letto i tuoi link sarei propenso ad andare con il primo, dal momento che dà una spiegazione simile alla mia.

Anche l’ associazione sta semplicemente invocando un metodo (inviando un messaggio) a un altro object tramite un riferimento a quell’object.

Per due oggetti Foo e Bar abbiamo:

Dipendenza:

 class Foo { ... fooMethod(Bar bar){} ... } 

Associazione:

 class Foo { private Bar bar; ... } 

Composizione: (quando Foo muore, Bar fa)

 class Foo { ... private Bar bar = new Bar(); ... } 

Aggregazione: (Quando Foo muore, Bar potrebbe sopravvivere)

 class Foo { private List bars; }