Agregación y Composición en C#

A lo largo de muchos años, trabajando en muchos proyectos, con muchos desarrolladores diferentes, me he dado cuenta que muchos programadores no tienen clara la diferencia entre composición y agregación, y que incluso confunden sus términos.

También hay quien confunde Agregación con Asociación, pero pongámonos ya el mono de trabajo.

El caso es que cuando he trabajado en proyectos con arquitectura DDD, se me hace casi incluso más necesario si cabe, entender bien su ámbito y uso.

De forma general, y a modo resumen, diré a modo recordatorio, que:

• La Herencia nos dice «es un«.
• La Composición nos dice «es parte de«.
• La Agregación nos dice «tiene un«.

Tanto la Agregación como la Composición, son dos tipos especiales de la Asociación.

Composición

La Composición, es una relación más fuerte que la Agregación.

La Composición se suele representar en UML con un rombo de color negro en un extremo de las clases.

Aquí, estaríamos diciendo que un objeto Car está compuesto por uno o varios objetos de tipo Wheel.

Por otro lado, también estamos diciendo que la clase Wheel es parte de la clase Car.

Dicho de otro modo, en esta relación, no tiene sentido que la clase Wheel viva de forma independiente sin formar parte de la clase Car.

También diremos que al eliminar la clase Car, eliminaremos por lo tanto, la clase Wheel, ya que la relación entre ambas clases, es estrecha.

De cara a nuestro código, la clase Car quedaría por ejemplo de la siguiente manera:

public class Car
{
    public Wheel wheel = new Wheel();

    public void AddWheelToWheels()
    {
        wheel.AddWheel();
    }

    public int CheckWheels()
    {
        return wheel.CheckWheels();
    }
}

La clase Wheel por su parte, quedaría de la siguiente manera:

public class Wheel
{
    private int _wheels;

    public void AddWheel()
    {
        _wheels += 1;
    }

    public int CheckWheels()
    {
        return _wheels;
    }
}

Agregación

La Agregación se suele representar en UML con un rombo de color transparente en un extremo de las clases.

Aunque la Asociación es una forma más débil de establecer una relación que la Agregación, la Agregación tiene una relación más débil que la Composición.

Tanto es así, que cuando eliminamos la clase Customer, no tenemos porqué eliminar la clase Order, de manera tal que la clase Order podría continuar existiendo.

Aquí, un Customer agrupa 0, 1 o muchas Orders.

Viendo algo de código, nuestra clase Customer quedaría de la siguiente forma:

public class Customer
{
    private Order _order;

    public Customer()
    {
        _order = new Order();
    }

    public Customer(Order order)
    {
        _order = order;
    }
        
    public void SetOrder(Order order)
    {
        _order = order;
    }

    public void AddItemToOrder()
    {
        _order.AddItem();
    }

    public int CheckItems()
    {
        return _order.CheckItems();
    }
}

Y la clase Order quedaría de la siguiente forma:

public class Order
{
    private int _items;

    public void AddItem()
    {
        _items += 1;
    }

    public int CheckItems()
    {
        return _items;
    }
}

Espero que esto le ayude a más de un programador.

¡Happy Coding!