Modelando el dominio

En el corazón de cualquier aplicación orientada al dominio está el modelo que representa el conocimiento central y las reglas de negocio del sistema. Modelar bien el dominio significa traducir conceptos del mundo real en estructuras de software expresivas, cohesivas y consistentes.

Entidades

Una entidad es un objeto definido principalmente por su identidad y no solo por sus atributos. Aunque los atributos cambien con el tiempo, la identidad de una entidad permanece igual.

Características principales:

Tiene una identidad única (generalmente un Id).
Lo que importa es quién es la entidad, no solo qué contiene.
Sus atributos pueden cambiar con el tiempo.

Creando una entidad con Lino

Para crear una nueva entidad utilizando Lino, ejecute:

lino entity new

El asistente del CLI solicitará:

Servicio – Servicio en el que se creará la entidad.
Módulo – Módulo donde se creará la entidad (solo en servicios modulares).
Nombre de la entidad – Nombre usado en el dominio y en la tabla de la base de datos.

Luego, definirás los campos que componen la entidad configurando cada uno de ellos.

Tipos de campos disponibles

Tipo	Descripción	Rango / Observaciones
`short`	Entero de 16 bits	-32 768 → 32 767
`int`	Entero de 32 bits	-2 147 483 648 → 2 147 483 647
`long`	Entero de 64 bits	-9 223 372 036 854 775 808 → 9 223 372 036 854 775 807
`string`	Texto	Hasta ~2 mil millones de caracteres
`bool`	Valor booleano	`true` o `false`
`Guid`	Identificador global único	Unicidad distribuida
`decimal`	Número decimal de alta precisión	Ideal para valores monetarios
`float`	Punto flotante (32 bits)	≈ 6–9 dígitos de precisión
`double`	Punto flotante (64 bits)	≈ 15–17 dígitos de precisión
`DateTime`	Fecha y hora	Incluye zona horaria
`DateOnly`	Sólo fecha (C# 10+)	–
`TimeOnly`	Sólo hora (C# 10+)	–
`Entity`	Referencia a otra entidad	1:1 o 1:N
`Value Object`	Objeto de valor inmutable	Ej.: Dirección, CPF
`Enum`	Enumeración	Conjunto fijo de valores
`List<Entity>`	Lista de entidades	1:N
`ManyToMany`	Muchos a muchos	Requiere tabla de unión

Ejemplo

Creando la entidad Person:

┌────┬────┬───────────────┬────────┬────────┬───────────┬────────────────┐
│ PK │ FK │ Property name │ Type   │ Length │ Required  │ Auto-increment │
├────┼────┼───────────────┼────────┼────────┼───────────┼────────────────┤
│ x  │    │ Id            │ int    │        │     x     │       x        │
├────┼────┼───────────────┼────────┼────────┼───────────┼────────────────┤
│    │    │ Name          │ string │  100   │     x     │                │
└────┴────┴───────────────┴────────┴────────┴───────────┴────────────────┘

Estructura generada por Lino:

MyApp/
└── src/
    └── Services/
        └── MyService/
            └── Domain/
                ├── MyApp.MyService.Domain.csproj
                └── Aggregates/
                    └── People/
                        ├── Person.cs
                        ├── Errors/
                        │   └── PersonErrors.cs
                        ├── Repositories/
                        │   └── IPersonRepository.cs
                        └── Resources/
                            └── Person/
                                ├── PersonResources.resx
                                ├── PersonResources.en.resx
                                └── PersonResources.pt-BR.resx

Después de definir tus entidades, usa Lino para gestionar las Migrations y mantener la base de datos sincronizada. Este proceso se abordará en detalle en la sección Capa de Persistencia.

Objetos de Valor

Un objeto de valor representa un concepto del dominio definido únicamente por sus atributos – no posee identidad propia. Dos objetos de valor se consideran iguales si todos sus valores son iguales.

Características principales:

Inmutables después de la creación.
No poseen Id.

Creando un objeto de valor con Lino

Ejecute:

lino value-object new

El CLI solicitará:

Servicio – Servicio en el que se creará el objeto.
Módulo – Módulo en el que se creará el objeto (solo en servicios modulares).
Ubicación – Raíz del dominio o agregado específico.
Nombre del objeto de valor.

Luego, defina los campos que componen el objeto.

Tipos de campos disponibles

Tipo	Descripción	Observaciones
`short`	Entero de 16 bits	-32.768 → 32.767
`int`	Entero de 32 bits	-2.147.483.648 → 2.147.483.647
`long`	Entero de 64 bits	-9.223.372.036.854.775.808 → 9.223.372.036.854.775.807
`string`	Texto	Hasta ~2 mil millones de caracteres
`bool`	Booleano	`true`/`false`
`decimal`	Decimal preciso	Valores monetarios
`float`	Punto flotante (32 bits)	≈ 6–9 dígitos
`double`	Punto flotante (64 bits)	≈ 15–17 dígitos
`DateTime`	Fecha/hora	Incluye zona horaria
`DateOnly`	Sólo fecha	C# 10+
`TimeOnly`	Sólo hora	C# 10+

Ejemplo

Objeto de valor Address:

┌───────────────┬────────┬────────┬───────────┐
│ Property name │ Type   │ Length │ Required  │
├───────────────┼────────┼────────┼───────────┤
│ Street        │ string │  100   │     x     │
├───────────────┼────────┼────────┼───────────┤
│ Number        │ string │   10   │     x     │
├───────────────┼────────┼────────┼───────────┤
│ Neighborhood  │ string │   50   │           │
├───────────────┼────────┼────────┼───────────┤
│ City          │ string │  100   │     x     │
├───────────────┼────────┼────────┼───────────┤
│ State         │ string │   2    │     x     │
├───────────────┼────────┼────────┼───────────┤
│ PostalCode    │ string │   20   │     x     │
├───────────────┼────────┼────────┼───────────┤
│ Country       │ string │  100   │     x     │
└───────────────┴────────┴────────┴───────────┘

Estructura de archivos generada (agregado Person):

MyApp/
└── src/
    └── Services/
        └── MyService/
            └── Domain/
                ├── MyApp.MyService.Domain.csproj
                └── Aggregates/
                    └── People/
                        ├── Person.cs
                        ├── ValueObjects/
                        │   └── Address.cs
                        ├── Errors/
                        │   ├── AddressErrors.cs
                        │   └── PersonErrors.cs
                        ├── Repositories/
                        │   └── IPersonRepository.cs
                        └── Resources/
                            ├── Address/
                            │   ├── AddressResources.resx
                            │   ├── AddressResources.en.resx
                            │   └── AddressResources.pt-BR.resx
                            └── Person/
                                ├── PersonResources.resx
                                ├── PersonResources.en.resx
                                └── PersonResources.pt-BR.resx

Así como en las entidades, las Migrations pueden ser gestionadas por Lino para mantener el modelo de datos sincronizado.

Enumeraciones

Las enumeraciones en DDD pueden ir más allá de los enum tradicionales de C#. Pueden ser objetos ricos que representan estados fijos, conteniendo validaciones, métodos auxiliares e incluso comportamiento.

Motivación:

Los enum de C# están limitados a un valor entero o cadena.
Modelar una Enumeración como clase ofrece mayor flexibilidad y expresividad.

Características principales:

Son clases que heredan de una base común y encapsulan Id y Nombre.
Permiten agregar validaciones, métodos auxiliares y comportamiento.

Creando una enumeración con Lino

Ejecute:

lino enum new

El asistente solicitará:

Servicio.
Módulo (si aplica).
Ubicación – raíz del dominio o agregado.
Nombre de la enumeración.
Tipo – enum tradicional o Smart Enum (class).
Almacenamiento – int o string en la base de datos.

Ejemplo

Enumeración PersonStatus:

┌───────┬───────────┬──────────────┐
│ Value │ Name      │ Display Name │
├───────┼───────────┼──────────────┤
│ 1     │ Active    │ Active       │
├───────┼───────────┼──────────────┤
│ 2     │ Inactive  │ Inactive     │
├───────┼───────────┼──────────────┤
│ 3     │ Suspended │ Suspended    │
├───────┼───────────┼──────────────┤
│ 4     │ Deleted   │ Deleted      │
└───────┴───────────┴──────────────┘

Estructura generada:

MyApp/
└── src/
    └── Services/
        └── MyService/
            └── Domain/
                ├── MyApp.MyService.Domain.csproj
                └── Aggregates/
                    └── People/
                        ├── Person.cs
                        ├── Enums/
                        │   └── PersonStatus.cs
                        ├── ValueObjects/
                        │   └── Address.cs
                        ├── Errors/
                        │   ├── AddressErrors.cs
                        │   └── PersonErrors.cs
                        ├── Repositories/
                        │   └── IPersonRepository.cs
                        └── Resources/
                            ├── Address/
                            │   ├── AddressResources.resx
                            │   ├── AddressResources.en.resx
                            │   └── AddressResources.pt-BR.resx
                            ├── Person/
                            │   ├── PersonResources.resx
                            │   ├── PersonResources.en.resx
                            │   └── PersonResources.pt-BR.resx
                            └── PersonStatus/
                                ├── PersonStatusResources.resx
                                ├── PersonStatusResources.en.resx
                                └── PersonStatusResources.pt-BR.resx

Almacenar el valor de una enumeración como string es válido y puede mejorar la legibilidad, pero suele ser menos eficiente en términos de rendimiento y almacenamiento. Por eso recomendamos almacenar el valor como int, y para mantener la integridad referencial y facilitar el mantenimiento, crear una entidad (tabla) auxiliar donde la clave primaria corresponda al valor de la enumeración.

Después de definir las enumeraciones, use Lino para generar y aplicar las Migrations, asegurando que la base de datos refleje el modelo de dominio. Vea detalles en la sección Capa de Persistencia.