Modellare il dominio

Al cuore di qualsiasi applicazione guidata dal dominio c’è il modello che rappresenta la conoscenza centrale e le regole di business del sistema. Modellare bene il dominio significa tradurre i concetti del mondo reale in strutture software espressive, coese e consistenti.

Entità

Un'entità è un oggetto definito principalmente dalla sua identità e non solo dai suoi attributi. Anche se gli attributi cambiano nel tempo, l'identità di un'entità rimane la stessa.

Caratteristiche principali:

Possiede un'identità unica (di solito un Id).
Ciò che conta è chi è l'entità, non solo cosa contiene.
I suoi attributi possono cambiare nel tempo.

Creare un'entità con Lino

Per creare una nuova entità usando Lino, esegui:

lino entity new

Il wizard CLI ti chiederà:

Servizio – Il servizio in cui l'entità sarà creata.
Modulo – Il modulo in cui sarà creata l'entità (solo per servizi modulari).
Nome dell'entità – Il nome usato nel dominio e nella tabella del database.

Successivamente, definirai i campi che compongono l'entità configurando ciascuno di essi.

Tipi di campi disponibili

Tipo	Descrizione	Intervallo / Note
`short`	Intero a 16 bit	-32.768 → 32.767
`int`	Intero a 32 bit	-2.147.483.648 → 2.147.483.647
`long`	Intero a 64 bit	-9.223.372.036.854.775.808 → 9.223.372.036.854.775.807
`string`	Testo	Fino a circa 2 miliardi di caratteri
`bool`	Valore booleano	`true` o `false`
`Guid`	Identificatore globale univoco	Unicità distribuita
`decimal`	Numero decimale ad alta precisione	Ideale per valori monetari
`float`	Punto flottante (32 bit)	≈ 6–9 cifre di precisione
`double`	Punto flottante (64 bit)	≈ 15–17 cifre di precisione
`DateTime`	Data e ora	Include il fuso orario
`DateOnly`	Solo data (C# 10+)	–
`TimeOnly`	Solo ora (C# 10+)	–
`Entity`	Riferimento a un'altra entità	1:1 o 1:N
`Value Object`	Oggetto di valore immutabile	Es.: Indirizzo, CPF
`Enum`	Enumerazione	Insieme fisso di valori
`List<Entity>`	Lista di entità	1:N
`ManyToMany`	Molti-a-molti	Richiede tabella di join

Esempio

Creazione dell'entità Person:

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

Struttura generata da 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

Dopo aver definito le tue entità, usa Lino stesso per gestire le Migrations e mantenere sincronizzato il database. Questo processo sarà trattato in dettaglio nella sezione Layer di Persistenza.

Oggetti di Valore

Un oggetto di valore rappresenta un concetto di dominio definito solo dai suoi attributi – non possiede un’identità propria. Due oggetti di valore sono considerati uguali se tutti i loro valori sono uguali.

Caratteristiche principali:

Immutabili dopo la creazione.
Non possiedono Id.

Creare un oggetto di valore con Lino

Esegui:

lino value-object new

Il CLI chiederà:

Servizio – Servizio in cui sarà creato l’oggetto.
Modulo – Modulo in cui sarà creato l’oggetto (solo nei servizi modulari).
Posizione – Radice del dominio o specifico aggregato.
Nome dell’oggetto di valore.

Quindi definisci i campi che compongono l’oggetto.

Tipi di campo disponibili

Tipo	Descrizione	Note
`short`	Intero a 16 bit	-32.768 → 32.767
`int`	Intero a 32 bit	-2.147.483.648 → 2.147.483.647
`long`	Intero a 64 bit	-9.223.372.036.854.775.808 → 9.223.372.036.854.775.807
`string`	Testo	Fino a ~2 miliardi di caratteri
`bool`	Booleano	`true`/`false`
`decimal`	Decimale preciso	Valori monetari
`float`	Virgola mobile (32 bit)	≈ 6–9 cifre
`double`	Virgola mobile (64 bit)	≈ 15–17 cifre
`DateTime`	Data/ora	Include fuso orario
`DateOnly`	Solo data	C# 10+
`TimeOnly`	Solo ora	C# 10+

Esempio

Oggetto di valore 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     │
└───────────────┴────────┴────────┴───────────┘

Struttura dei file generata (aggregato 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

Come per le entità, le Migrations possono essere gestite da Lino per mantenere il modello dati sincronizzato.

Enumerazioni

Le enumerazioni nel DDD possono andare oltre i tradizionali enum di C#. Possono essere oggetti ricchi che rappresentano stati fissi, contenenti validazioni, metodi ausiliari e persino comportamenti.

Motivazione:

I enum di C# sono limitati a un valore intero o stringa.
Modellare un'Enumeration come classe offre maggiore flessibilità ed espressività.

Caratteristiche principali:

Sono classi che ereditano da una base comune e incapsulano Id e Nome.
Permettono di aggiungere validazioni, metodi ausiliari e comportamenti.

Creare un'enumerazione con Lino

Esegui:

lino enum new

L'assistente richiederà:

Servizio.
Modulo (se applicabile).
Posizione – radice del dominio o aggregato.
Nome dell'enumerazione.
Tipo – enum tradizionale o Smart Enum (class).
Archiviazione – int o string nel database.

Esempio

Enumerazione PersonStatus:

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

Struttura generata:

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

Archiviare il valore di un'enumerazione come string è valido e può migliorare la leggibilità, ma tende ad essere meno efficiente in termini di prestazioni e spazio di archiviazione. Per questo, consigliamo di archiviare il valore come int e, per mantenere l'integrità referenziale e facilitare la manutenzione, creare un'entità (tabella) ausiliaria dove la chiave primaria corrisponda al valore dell'enumerazione.

Dopo aver definito le enumerazioni, usa Lino per generare e applicare le Migrations, garantendo che il database rifletta il modello di dominio. Vedi i dettagli nella sezione Layer di Persistenza.