Lino - Documentação - Modelando o domínio

Entidades

Uma entidade é um objeto definido principalmente pela sua identidade e não apenas pelos seus atributos. Mesmo que os atributos mudem ao longo do tempo, a identidade de uma entidade permanece a mesma.

Características principais:

Possui uma identidade única (geralmente um Id).
Aquilo que importa é quem a entidade é, não apenas o que ela contém.
Seus atributos podem mudar ao longo do tempo.

Criando uma entidade com o Lino

Para criar uma nova entidade utilizando o Lino, execute:

lino entity new

O assistente do CLI solicitará:

Serviço – Serviço no qual a entidade será criada.
Módulo – Módulo em que a entidade será criada (apenas em serviços modulares).
Nome da entidade – Nome utilizado no domínio e na tabela do banco de dados.

Em seguida, você definirá os campos que compõem a entidade, configurando cada um deles.

Tipos de campos disponíveis

Tipo	Descrição	Faixa / Observações
`short`	Inteiro de 16 bits	-32 768 → 32 767
`int`	Inteiro de 32 bits	-2 147 483 648 → 2 147 483 647
`long`	Inteiro de 64 bits	-9 223 372 036 854 775 808 → 9 223 372 036 854 775 807
`string`	Texto	Até ~2 bilhões de caracteres
`bool`	Valor booleano	`true` ou `false`
`Guid`	Identificador global único	Unicidade distribuída
`decimal`	Número decimal de alta precisão	Ideal p/ valores monetários
`float`	Ponto flutuante (32 bits)	≈ 6–9 dígitos de precisão
`double`	Ponto flutuante (64 bits)	≈ 15–17 dígitos de precisão
`DateTime`	Data e hora	Inclui fuso horário
`DateOnly`	Só data (C# 10+)	–
`TimeOnly`	Só hora (C# 10+)	–
`Entity`	Referência a outra entidade	1 : 1 ou 1 : N
`Value Object`	Objeto de valor imutável	Ex.: Endereço, CPF
`Enum`	Enumeração	Conjunto fixo de valores
`List<Entity>`	Lista de entidades	1 : N
`ManyToMany`	Muitos‑para‑muitos	Requer tabela de junção

Exemplo

Criando a entidade Person:

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

Estrutura gerada pelo 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

Depois de definir suas entidades, use o próprio Lino para gerenciar as Migrations e manter o banco de dados sincronizado. Abordaremos esse processo em detalhes na seção Camada de Persistência.

Objetos de Valor

Um objeto de valor representa um conceito do domínio definido apenas pelos seus atributos – ele não possui identidade própria. Dois objetos de valor são considerados iguais se todos os seus valores forem iguais.

Características principais:

Imutáveis após a criação.
Não possuem Id.

Criando um objeto de valor com o Lino

Execute:

lino value-object new

O CLI solicitará:

Serviço – Serviço no qual o objeto será criado.
Módulo – Módulo em que o objeto será criado (apenas em serviços modulares).
Localização – Raiz do domínio ou agregado específico.
Nome do objeto de valor.

Em seguida, defina os campos que compõem o objeto.

Tipos de campos disponíveis

Tipo	Descrição	Observações
`short`	Inteiro de 16 bits	-32 768 → 32 767
`int`	Inteiro de 32 bits	-2 147 483 648 → 2 147 483 647
`long`	Inteiro de 64 bits	-9 223 372 036 854 775 808 → 9 223 372 036 854 775 807
`string`	Texto	Até ~2 bilhões de caracteres
`bool`	Booleano	`true`/`false`
`decimal`	Decimal preciso	Valores monetários
`float`	Ponto flutuante (32 bits)	≈ 6–9 dígitos
`double`	Ponto flutuante (64 bits)	≈ 15–17 dígitos
`DateTime`	Data/hora	Inclui fuso
`DateOnly`	Somente data	C# 10+
`TimeOnly`	Somente hora	C# 10+

Exemplo

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

Estrutura de arquivos gerada (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

Assim como nas entidades, as Migrations podem ser gerenciadas pelo Lino para manter o modelo de dados em sincronia.

Enumerações

As enumerações em DDD podem ir além dos enum tradicionais do C#. Elas podem ser objetos ricos que representam estados fixos, contendo validações, métodos auxiliares e até comportamento.

Motivação:

Os enum do C# são limitados a um valor inteiro ou string.
Modelar uma Enumeration como classe oferece maior flexibilidade e expressividade.

Características principais:

São classes que herdam de uma base comum e encapsulam Id e Nome.
Permitem adicionar validações, métodos auxiliares e comportamento.

Criando uma enumeração com o Lino

Execute:

lino enum new

O assistente solicitará:

Serviço.
Módulo (se aplicável).
Localização – Raiz do domínio ou agregado.
Nome da enumeração.
Tipo – enum tradicional ou Smart Enum (class).
Armazenamento – int ou string no banco de dados.

Exemplo

Enumeração PersonStatus:

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

Estrutura gerada:

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

Armazenar o valor de uma enumeração como string é válido e pode melhorar a legibilidade, mas tende a ser menos eficiente em termos de desempenho e armazenamento. Por isso, recomendamos armazenar o valor como int, e, para manter a integridade referencial e facilitar a manutenção, criar uma entidade (tabela) auxiliar onde a chave primária corresponda ao valor da enumeração.

Após definir as enumerações, utilize o Lino para gerar e aplicar as Migrations, garantindo que o banco de dados reflita o modelo de domínio. Veja detalhes na seção Camada de Persistência.