Domänenmodellierung

Im Herzen jeder domänenorientierten Anwendung steht das Modell, das das zentrale Wissen und die Geschäftsregeln des Systems repräsentiert. Das Domänenmodell gut zu gestalten bedeutet, Konzepte der realen Welt in ausdrucksstarke, zusammenhängende und konsistente Softwarestrukturen zu übersetzen.

Entitäten

Eine Entität ist ein Objekt, das hauptsächlich durch seine Identität definiert ist und nicht nur durch seine Attribute. Auch wenn sich die Attribute im Laufe der Zeit ändern, bleibt die Identität einer Entität gleich.

Hauptmerkmale:

Hat eine eindeutige Identität (normalerweise ein Id).
Wichtig ist, wer die Entität ist, nicht nur was sie enthält.
Die Attribute können sich im Laufe der Zeit ändern.

Erstellen einer Entität mit Lino

Um eine neue Entität mit Lino zu erstellen, führen Sie aus:

lino entity new

Der CLI-Assistent fragt nach:

Dienst – Dienst, in dem die Entität erstellt wird.
Modul – Modul, in dem die Entität erstellt wird (nur bei modularen Diensten).
Entitätsname – Name, der in der Domäne und der Datenbanktabelle verwendet wird.

Dann definieren Sie die Felder, aus denen die Entität besteht, und konfigurieren jedes einzelne.

Verfügbare Feldtypen

Typ	Beschreibung	Bereich / Anmerkungen
`short`	16-Bit Ganzzahl	-32 768 → 32 767
`int`	32-Bit Ganzzahl	-2 147 483 648 → 2 147 483 647
`long`	64-Bit Ganzzahl	-9 223 372 036 854 775 808 → 9 223 372 036 854 775 807
`string`	Text	Bis zu ~2 Milliarden Zeichen
`bool`	Boolescher Wert	`true` oder `false`
`Guid`	Eindeutiger globaler Bezeichner	Verteilte Eindeutigkeit
`decimal`	Dezimalzahl mit hoher Genauigkeit	Ideal für monetäre Werte
`float`	Gleitkommazahl (32 Bit)	≈ 6–9 Stellen Genauigkeit
`double`	Gleitkommazahl (64 Bit)	≈ 15–17 Stellen Genauigkeit
`DateTime`	Datum und Uhrzeit	Beinhaltet Zeitzone
`DateOnly`	Nur Datum (C# 10+)	–
`TimeOnly`	Nur Uhrzeit (C# 10+)	–
`Entity`	Verweis auf eine andere Entität	1:1 oder 1:N
`Value Object`	Unveränderliches Wertobjekt	z.B. Adresse, CPF
`Enum`	Aufzählung	Feste Menge von Werten
`List<Entity>`	Liste von Entitäten	1:N
`ManyToMany`	Viele-zu-viele	Erfordert Verknüpfungstabelle

Beispiel

Erstellen der Entität Person:

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

Vom Lino generierte Struktur:

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

Nachdem Sie Ihre Entitäten definiert haben, verwenden Sie Lino, um die Migrations zu verwalten und die Datenbank synchron zu halten. Dieser Prozess wird im Abschnitt Persistenzschicht ausführlich behandelt.

Wertobjekte

Ein Wertobjekt repräsentiert ein Domänenkonzept, das ausschließlich durch seine Attribute definiert wird – es besitzt keine eigene Identität. Zwei Wertobjekte gelten als gleich, wenn alle ihre Werte übereinstimmen.

Hauptmerkmale:

Unveränderlich nach der Erstellung.
Besitzen keine Id.

Erstellen eines Wertobjekts mit Lino

Führen Sie aus:

lino value-object new

Das CLI wird fragen nach:

Service – Service, in dem das Objekt erstellt wird.
Modul – Modul, in dem das Objekt erstellt wird (nur in modularen Services).
Ort – Domänenwurzel oder spezifisches Aggregat.
Name des Wertobjekts.

Definieren Sie anschließend die Felder, die das Objekt ausmachen.

Verfügbare Feldtypen

Typ	Beschreibung	Anmerkungen
`short`	16-Bit-Ganzzahl	-32.768 → 32.767
`int`	32-Bit-Ganzzahl	-2.147.483.648 → 2.147.483.647
`long`	64-Bit-Ganzzahl	-9.223.372.036.854.775.808 → 9.223.372.036.854.775.807
`string`	Text	Bis zu ~2 Milliarden Zeichen
`bool`	Boolean	`true`/`false`
`decimal`	Präzise Dezimalzahl	Monetäre Werte
`float`	Gleitkommazahl (32 Bit)	≈ 6–9 Stellen
`double`	Gleitkommazahl (64 Bit)	≈ 15–17 Stellen
`DateTime`	Datum/Uhrzeit	Enthält Zeitzone
`DateOnly`	Nur Datum	C# 10+
`TimeOnly`	Nur Uhrzeit	C# 10+

Beispiel

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

Generierte Dateistruktur (Aggregat 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

Wie bei Entitäten können Migrations von Lino verwaltet werden, um das Datenmodell synchron zu halten.

Enumeration

Enumeration in DDD können über die traditionellen enum-Typen von C# hinausgehen. Sie können reichhaltige Objekte sein, die feste Zustände repräsentieren, Validierungen, Hilfsmethoden und sogar Verhalten enthalten.

Motivation:

Die C#-enum-Typen sind auf einen ganzzahligen oder string-Wert beschränkt.
Das Modellieren einer Enumeration als Klasse bietet mehr Flexibilität und Ausdruckskraft.

Hauptmerkmale:

Es sind Klassen, die von einer gemeinsamen Basis erben und Id und Name kapseln.
Sie erlauben das Hinzufügen von Validierungen, Hilfsmethoden und Verhalten.

Erstellen einer Enumeration mit Lino

Führen Sie aus:

lino enum new

Der Assistent wird nach Folgendem fragen:

Service.
Modul (falls zutreffend).
Ort – Root des Domänens oder Aggregats.
Name der Enumeration.
Typ – traditionelles enum oder Smart Enum (class).
Speicherung – int oder string in der Datenbank.

Beispiel

Enumeration PersonStatus:

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

Generierte Struktur:

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

Das Speichern des Werts einer Enumeration als string ist gültig und kann die Lesbarkeit verbessern, ist jedoch in Bezug auf Leistung und Speicher ineffizienter. Daher empfehlen wir, den Wert als int zu speichern und zur Wahrung der referenziellen Integrität und zur Vereinfachung der Wartung eine Hilfsentität (Tabelle) zu erstellen, bei der der Primärschlüssel dem Wert der Enumeration entspricht.

Nachdem Sie die Enumerationen definiert haben, verwenden Sie Lino, um die Migrations zu generieren und anzuwenden, damit die Datenbank das Domänenmodell widerspiegelt. Details finden Sie im Abschnitt Persistenzschicht.