Arquitectura de Software con C# 10: Implementación de Entidades, Agregados y Value Objects en Clean Architecture

Introducción a la clase

En la clase anterior aprendimos cómo integrar Domain-Driven Design (DDD) en Clean Architecture. Ahora profundizaremos en la implementación práctica de Entidades, Agregados y Value Objects en un proyecto real en C#.

¿Qué obtendrás de esta clase?

• Aprenderás cómo modelar Entidades, Agregados y Value Objects en Clean Architecture.
• Implementarás un dominio basado en DDD dentro de la Capa de Dominio.
• Verás ejemplos de cómo estos conceptos mejoran la cohesión y consistencia del negocio.
• Conocerás buenas prácticas y errores comunes al modelar el dominio.

Paso 1: Creación de Entidades en la Capa de Dominio

Las Entidades representan objetos del dominio con una identidad única y lógica de negocio.

Ejemplo en C#: Entidad Pedido

public class Pedido
{
    public int Id { get; private set; }
    public string Cliente { get; private set; }
    public DateTime Fecha { get; private set; }
    private readonly List<Producto> _productos = new List<Producto>();

    public IReadOnlyCollection<Producto> Productos => _productos.AsReadOnly();

    public Pedido(int id, string cliente)
    {
        Id = id;
        Cliente = cliente;
        Fecha = DateTime.UtcNow;
    }

    public void AgregarProducto(Producto producto)
    {
        _productos.Add(producto);
    }

    public decimal CalcularTotal()
    {
        return _productos.Sum(p => p.Precio);
    }
}

Buenas prácticas en Entidades:

• Privatizar setters para evitar modificaciones no controladas.
• Usar listas privadas para evitar modificaciones directas.
• Exponer datos a través de métodos y propiedades de solo lectura.

Paso 2: Creación de Value Objects en la Capa de Dominio

Los Value Objects representan conceptos sin identidad única y deben ser inmutables.

Ejemplo en C#: Value Object «Dirección»

public class Direccion
{
    public string Calle { get; }
    public string Ciudad { get; }
    public string CodigoPostal { get; }

    public Direccion(string calle, string ciudad, string codigoPostal)
    {
        Calle = calle;
        Ciudad = ciudad;
        CodigoPostal = codigoPostal;
    }

    public override bool Equals(object obj)
    {
        if (obj is Direccion other)
        {
            return Calle == other.Calle && Ciudad == other.Ciudad && CodigoPostal == other.CodigoPostal;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Calle, Ciudad, CodigoPostal);
    }
}

Buenas prácticas en Value Objects:

• Inmutabilidad: No modificar los valores después de la creación.
• Comparación por valores, no por referencia.
• Pequeños y reutilizables dentro del dominio.

Paso 3: Creación de un Agregado en la Capa de Dominio

Un Agregado es un grupo de Entidades y Value Objects que forman una unidad lógica dentro del dominio.

Ejemplo en C#: Agregado Pedido con Productos

public class Pedido
{
    public int Id { get; private set; }
    public string Cliente { get; private set; }
    private readonly List<Producto> _productos = new List<Producto>();

    public IReadOnlyCollection<Producto> Productos => _productos.AsReadOnly();

    public Pedido(int id, string cliente)
    {
        Id = id;
        Cliente = cliente;
    }

    public void AgregarProducto(Producto producto)
    {
        _productos.Add(producto);
    }

    public decimal CalcularTotal()
    {
        return _productos.Sum(p => p.Precio);
    }
}

public class Producto
{
    public int Id { get; private set; }
    public string Nombre { get; private set; }
    public decimal Precio { get; private set; }

    public Producto(int id, string nombre, decimal precio)
    {
        Id = id;
        Nombre = nombre;
        Precio = precio;
    }
}

Buenas prácticas en Agregados:

• Encapsular la lógica dentro de la entidad raíz (en este caso, Pedido).
• Evitar relaciones innecesarias dentro del agregado.
• Exponer solo métodos necesarios para modificar el agregado.

Errores comunes al implementar Entidades, Agregados y Value Objects

• Exponer listas directamente en los Agregados.
  Solución: Usar listas privadas con métodos controlados.
• Modificar los valores de un Value Object.
  Solución: Hacerlos inmutables (solo con getters).
• No definir un Agregado cuando es necesario.
  Solución: Agrupar entidades relacionadas en una unidad lógica coherente.

Cuestionario de Autoevaluación

• ¿Cuál es la diferencia entre una Entidad y un Value Object?
• ¿Por qué los Value Objects deben ser inmutables?
• ¿Cómo protege un Agregado la consistencia de los datos en el dominio?
• ¿Qué ventajas tiene encapsular listas dentro de un Agregado?
• ¿Cuál es la importancia de privatizar setters en Entidades?

Resumen de la Clase

• Las Entidades tienen identidad única y pueden modificarse a lo largo del tiempo.
• Los Value Objects no tienen identidad y son inmutables.
• Los Agregados agrupan Entidades y Value Objects en una unidad lógica.
• Buenas prácticas en DDD incluyen encapsulación, inmutabilidad y control de acceso.

Próximo paso

En la siguiente clase veremos cómo desacoplar las dependencias con interfaces y la inversión de dependencias en Clean Architecture.