Composition And Aggregation

Composition

In general terms, composition is a process of combining two or more elements to form a whole in such a way that the life of all the elements depend on each other.

In computing terms, Composition is a special form of Association where entities becomes a part-of relationship or association which means the life of one entity becomes dependent on one other. For example, a section becomes a part of an Article – if you delete an article then all the sections contained within that article will be removed along with that article.

Looking at the relationship termed Composition, we can easily figure out that one entity becomes a composite object and others becomes components of a composite object, for example Article is a composite object whereas Section becomes a component of composite object.

Composite object takes ownership of the component, composite is responsible for the creation and destruction of the component parts. Composition helps us in implementing encapsulation as the component parts usually are members of the composite object.

In UML notation, Composition is depicted as a filled diamond and a solid line for example one or many sections can be part of an article.

Implementation in C#

There are different ways to implement Composition relationship in C# but I personally prefer to use Nested Classes

publicclassArticle {
privatereadonlyList < Section > _sections = newList < Section > ();
public Article() {
_sections.Add(newSection() {
Heading = "Heading 1", Paragraph = "Text Goes Here......."
});
Console.WriteLine("Article Created Successfully with one default section.");
}
publicvoid AddSection() {
Section section = newSection() {
Heading = "Heading 1", Paragraph = "Text Goes Here......."
};
_sections.Add(section);
Console.WriteLine("Section Added Successfully. {0} Section Added in an Article ", _sections.Count);
}
classSection {
publicstring Heading {
get;
set;
}
publicstring Paragraph {
get;
set;
}
}
}

Aggregation

In general terms, Aggregation is a process of combining two or more distinct components to form an aggregate (whole) object but individual components have their own life-cycle.

In computing terms, Aggregation is a form of Association where different components combine to form a relationship or association between the aggregate (whole) and components in which the components live their own life-cycle; for example, we combine different network adapters, routers and network switches to build a complete network. If we take out any network switch or router, it will not impact any other component or network and we should be able to access network as expected. Similarly if we delete the network completely, it should not impact any individual component and we should be able to access those components without going through the aggregate object.

Aggregate object takes ownership of the component, but aggregate object is not responsible for the creation and destruction of the component parts, meaning the component object may live longer than the aggregate object.

In UML notation, Aggregation is depicted as an empty diamond and a solid line for example one or many Network Switch, Network Adaptor and Router combine to form a Network.

As seen in the above UML diagram NetworkSwitch, NetworkAdapter and Router aggregate themselves to form a Network and it is not mandatory for individual NetworkSwitch, NetworkAdapter and Router to be part of any Network, meaning they have their own life-cycle and can be accessed through their individual object.

Implementation in C#

classNetwork {
privatereadonlyList < Router > _routers = newList < Router > ();
privatereadonlyList < NetworkSwitch > _networkSwitches = newList < NetworkSwitch > ();
privatereadonlyList < NetworkAdpater > _networkAdapters = newList < NetworkAdpater > ();
publicstring NetworkName {
get;
set;
}
publicvoid AddNetworkSwitch(NetworkSwitch networkSwitch) {
_networkSwitches.Add(networkSwitch);
Console.WriteLine("Switch {0} Added to the Network {1} ", networkSwitch.NetworkSwitchId, NetworkName);
}
publicvoid RemoveNetworkSwitch(NetworkSwitch networkSwitch) {
_networkSwitches.Remove(networkSwitch);
Console.WriteLine("Switch {0} removed from the Network {1} ", networkSwitch.NetworkSwitchId, NetworkName);
}
publicvoid AddNetworkAdapter(NetworkAdpater networkAdpater) {
_networkAdapters.Add(networkAdpater);
Console.WriteLine("Switch {0} Added to the Network {1} ", networkAdpater.NetworkAdpaterId, NetworkName);
}
publicvoid RemoveNetworkAdpater(NetworkAdpater networkAdpater) {
_networkAdapters.Remove(networkAdpater);
Console.WriteLine("Switch {0} removed from the Network {1}", networkAdpater.NetworkAdpaterId, NetworkName);
}
publicvoid AddRouter(Router router) {
_routers.Add(router);
Console.WriteLine("Router {0} Added to the Network {1} ", router.RouterId, NetworkName);
}
publicvoid RemoveRouter(Router router) {
_routers.Remove(router);
Console.WriteLine("Router {0} removed from the Network {1}", router.RouterId, NetworkName);
}
publicvoid PrintNetworkInformation() {
foreach(var networkAdpater in _networkAdapters) {
Console.WriteLine("{0} has a adapter {1}", NetworkName, networkAdpater.NetworkAdpaterId, NetworkName);
}
foreach(var networkSwitch in _networkSwitches) {
Console.WriteLine("{0} has a switch {1}", NetworkName, networkSwitch.NetworkSwitchId, NetworkName);
}
foreach(var router in _routers) {
Console.WriteLine("{0} has a router {1}", NetworkName, router.RouterId, NetworkName);
}
}
}
classNetworkSwitch {
publicstring NetworkSwitchId {
get;
set;
}
publicstring Description {
get;
set;
}
}
classNetworkAdpater {
publicstring NetworkAdpaterId {
get;
set;
}
publicstring Description {
get;
set;
}
}
classRouter {
publicstring RouterId {
get;
set;
}
publicstring Description {
get;
set;
}
}

Now we can initialize and access an instance of NetworkSwitch, NetworkAdpater and Router individually and add them to a network object and remove them from network whenever needed. Adding and removing an instance of NetworkSwitch from Network object will not make any impact on the individual NetworkSwitch object

Conclusion

Composition and Aggregation both are subset of Association. Aggregation differs from composition in that it does not enforce ownership and the aggregate (whole) object does not take responsibility for the creation and destruction of components.

Tip

Use composition when one object needs to be developed as an integral part of another object.