用于关联、聚合、组合的C#代码

Question

我试图确认我对关联、聚合的代码外观的理解

聚合：哈斯-a。它具有另一种类型的现有对象

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

组成：由另一个对象组成

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

协会：我对此有两种看法。

>

当一个类与另一个类相关联时。因此，上述两个都是关联的示例。

关联是一种较弱的聚合形式，其中类不保留对其接收的对象的引用。

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

我的理解正确吗？我在这里和这里阅读了相互矛盾的文章，所以我真的不确定该遵循哪一个。我的理解似乎符合第一个环节。我觉得第二个环节是错误的，或者也许我没有正确理解它。

你怎么想呢?

Answer 1

如果继承给了我们< code>'is-a'，而合成给了我们< code>'part-of'，我们可以认为聚合给了我们一个< code>'has-a'关系。

==

关联
1. ：关联意味着一个对象“使用”另一个对象。正如你所说：“关联是一种较弱的聚合形式，其中类不保留对它接收的对象的引用。

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

• 聚合是一种特殊类型的关联。
• 聚合是对象之间的“有”关系（白色菱形）
• 例如，人员“有”地址。

public class Address  
{  
 . . .  
}  
public class Person  
{  
     private Address address;  
     public Person(Address address)  
     {  
         this.address = address;  
     }  
     . . .  
}  

如您所见，此人不会管理地址的生命周期。如果人员被销毁，则地址仍然存在。

• 合成是一种特殊的聚合类型，它是一种强聚合类型
• 组合为我们提供了一种“部分”关系（暗菱形）。发动机是汽车的一部分

public class Engine  
{  
 . . .   
}  
public class Car  
{  
    Engine e = new Engine();  
    .......  
}  

请点击以下链接获取未来信息：

• https://www.c-sharpcorner.com/UploadFile/ff2f08/association-aggregation-and-composition/
• https://www.c-sharpcorner.com/article/difference-between-composition-and-aggregation/

Answer 2

聚合和组合之间的区别非常模糊，AFAIK 与容器被销毁后“子”对象的逻辑存在有关。因此，在聚合的情况下，容器中的对象在容器对象被销毁后仍然可以存在，而在组合设计的情况下，它们也需要被销毁。一些类比：

• 一个包含四个Wheel对象的Car。通常情况下，如果你破坏了汽车（通过调用某种方法来清理），你也应该在这个过程中破坏车轮，因为它们存在于汽车之外没有什么意义（除非你将它们移动到另一个car对象）。更现实的是，包装输入流的读取器对象在内部流自身关闭时也会关闭内部流。这是作文
• Person对象包含（拥有）Radio的对象。如果Person死亡，则Radio可能会被另一个Person继承，即它在没有原始所有者的情况下存在是合理的。更现实的是，保存对象的列表并不要求在释放列表本身时释放所有对象。这是聚合

编辑：在阅读了你的链接后，我倾向于使用第一个，因为它给出了与我类似的解释。

关联也仅仅是通过对另一个对象的引用调用一个方法（发送消息）到另一个对象。

Answer 3

对于两个对象 Foo 和 Bar，我们有：

依赖性:

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

协会：

class Foo
{
    private Bar bar;
    ...
}

作曲：（当阿福死了，巴也死了）

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

聚合：（当Foo死亡时，Bar可能会继续存在）

class Foo 
{
    private List<Bar> bars;
}