Domänenmodellierung

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

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:

<ProjectName>/
└── src/
    └── Services/
        └── <ServiceName>/
            └── Domain/
                ├── <ProjectName>.<ServiceName>.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.

Aktueller Evolutionsablauf

Neben dem interaktiven Ablauf mit lino entity new kann die CLI die Absicht auch direkt im Befehl ausdrücken, wenn Service, Modul und Name bereits bekannt sind:

lino entity new --name <EntityName> --service <ServiceName> --module <ModuleName>
lino entity edit --service <ServiceName> --module <ModuleName> --entity <EntityName>
lino entity list --service <ServiceName> --module <ModuleName>

Verwenden Sie entity list, bevor Sie in großen Modulen neue Konzepte erstellen. Prüfen Sie bei Änderungen Identifier, Properties, Pflichtangaben, Länge, Beziehungen, Indizes, Ownership, Tenant und Auswirkungen auf Migrations.

Strongly Typed IDs, Ownership und Invarianten

Wenn Strongly Typed IDs aktiviert sind, wird der Identifier zu einem dedizierten Typ, etwa ProductId, wodurch versehentliche Vertauschungen von IDs verschiedener Entitäten reduziert werden. Beziehungen sollten das tatsächliche Ownership im Domänenmodell widerspiegeln: Nicht jede Referenz muss zu einer direkten Navigation werden; oft schützen ein Identifier, eine Shadow Entity, ein Integration Event oder eine explizite Abfrage Modulgrenzen besser.

Legen Sie Invarianten in die Domäne, nicht nur in die UI, Datenbank oder Validators. Führen Sie nach Änderungen an Entitäten einen Build aus, prüfen Sie den Diff und generieren oder aktualisieren Sie Migrations.

Value Objects

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

Hauptmerkmale:

• Unveränderlich nach der Erstellung.
• Besitzen keine Id.

Erstellen eines Value Object 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 Value Object.

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

Verfügbare Feldtypen

Beispiel

Value Object 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):

<ProjectName>/
└── src/
    └── Services/
        └── <ServiceName>/
            └── Domain/
                ├── <ProjectName>.<ServiceName>.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.

Aktueller Evolutionsablauf

Neben dem interaktiven Befehl können Sie Parameter verwenden, wenn bereits klar ist, wo das Konzept entstehen soll:

lino value-object new --name <ValueObjectName> --service <ServiceName> --module <ModuleName>
lino value-object edit --service <ServiceName> --module <ModuleName> --value-object <ValueObjectName>
lino value-object list --service <ServiceName> --module <ModuleName>

Wenn eine Entitätseigenschaft als ValueObject deklariert wird, kann Lino ein vorhandenes Value Object wiederverwenden oder während der Entitätsmodellierung ein neues erstellen. Bevorzugen Sie diese Option, wenn die Felder ein gemeinsames Konzept darstellen, etwa Geld, Adresse, Abmessungen, Zeitraum oder Dokument.

Persistenz, UI und Lokalisierung

Lino mappt Eigenschaften von Value Objects über die Persistenzschicht des Moduls und überträgt Anzeigemetadaten in Resources. Dadurch werden lokalisierte Labels und Meldungen für verschachtelte Werte möglich. Das Value Object gehört zu dem Modul, in dem es generiert wurde; ohne explizite Integration wird es nicht zu einem gemeinsam genutzten Vertrag zwischen Modulen.

Schützen Sie Invarianten im Typ selbst: Negative Werte, ungültige Währungen, invertierte Zeiträume oder fehlerhafte Dokumente sollten nicht gültig erzeugt werden können.

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 enumeration 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:

<ProjectName>/
└── src/
    └── Services/
        └── <ServiceName>/
            └── Domain/
                ├── <ProjectName>.<ServiceName>.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.

Aktueller Evolutionsablauf

Neben dem interaktiven Befehl können Sie Parameter verwenden, wenn Speicherort und Name bereits feststehen:

lino enumeration new --name <EnumerationName> --service <ServiceName> --module <ModuleName>
lino enumeration edit --service <ServiceName> --module <ModuleName> --enumeration <EnumerationName>
lino enumeration list --service <ServiceName> --module <ModuleName>

Enumeration, Entität oder Konfiguration

Wenn die Enumeration einen Anzeigenamen bereitstellt, kann Lino Resources für lokalisierte Labels generieren. Wenn sie persistiert oder als Seed Data verwendet wird, prüfen Sie Migrations nach dem Hinzufügen, Entfernen oder Umbenennen von Werten. Konsistenz zwischen Code, Datenbank und UI ist Teil der Domänenänderung.