9. Schichtenarchitektur und Datenzugriff
Die bisherigen Beispiele hielten ihre Daten im Speicher. Eine reale Anwendung speichert sie in einer Datenbank und ist in Schichten organisiert (siehe das Diagramm in der Einführung):
- die Web-Schicht (Controller, Views): liest die Anfrage, ruft die Geschäftsschicht auf, wählt die View aus;
- die Geschäfts-Schicht: Geschäftsregeln;
- die DAO-Schicht ([Data Access Object]): Datenbankabfragen.
Jede Schicht kennt nur die darunterliegende Schicht und möglichst wenige Details über sie: Die Web-Schicht kennt kein SQL, und die Geschäftsschicht kennt kein HTML. Diese Trennung macht jede Schicht leichter verständlich, testbar und weiterentwickelbar. Beispiel 28 wendet dies auf die Verwaltung einer Personenliste an: Es ist, im kleineren Maßstab, die Verwaltung der Ärzte und Klienten aus der Fallstudie.
Der Datenbankzugriff erfolgt über Entity Framework Core (EF Core), den ORM ([Object-Relational Mapper]) von [.NET]: Er bildet [C#]-Klassen (die Entitäten) auf die Datenbanktabellen ab, übersetzt in [LINQ] geschriebene Abfragen in SQL und wandelt die abgerufenen Zeilen in Objekte um. EF Core kommuniziert mit jedem Datenbanktyp über einen Provider ([provider]): für [MySQL] das [NuGet]-Paket [Pomelo.EntityFrameworkCore.MySql], das wiederum EF Core und den Treiber [MySqlConnector] einbindet.
9.1. Beispiel 28: Eine dreischichtige Personalverwaltung
| 28-layers/
├── Business/
│ ├── BusinessException.cs
│ └── PersonsBusiness.cs
├── Controllers/
│ └── PersonsController.cs
├── Dao/
│ └── PersonsDao.cs
├── Data/
│ └── PersonsDbContext.cs
├── database/
│ └── dbpersons.sql
├── Entities/
│ └── Person.cs
├── Models/
│ └── PersonForm.cs
├── Views/
│ ├── Persons/
│ │ ├── Form.cshtml
│ │ └── List.cshtml
│ ├── Shared/
│ │ ├── _Confirmation.cshtml
│ │ ├── _Field.cshtml
│ │ └── _Layout.cshtml
│ ├── _ViewImports.cshtml
│ └── _ViewStart.cshtml
├── wwwroot/
│ ├── css/
│ │ └── styles.css
│ └── js/
│ └── app.js
├── appsettings.json
├── Example28.csproj
└── Program.cs
|
9.1.1. Die Datenbank
Die Datenbank [dbpersons] wird durch ein SQL-Skript erstellt. Mit [Laragon] können Sie es beispielsweise im Tool [HeidiSQL] ausführen (Menü Datei / SQL-Datei ausführen) oder über die Befehlszeile:
| mysql -u root < database/dbpersons.sql
|
Die Datei [database/dbpersons.sql]:
| -- Datenbank von Beispiel 28: eine einzige Tabelle, [persons]
DROP DATABASE IF EXISTS dbpersons;
CREATE DATABASE dbpersons CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE dbpersons;
CREATE TABLE persons (
id INT NOT NULL AUTO_INCREMENT,
version INT NOT NULL DEFAULT 1,
first_name VARCHAR(30) NOT NULL,
last_name VARCHAR(30) NOT NULL,
age INT NOT NULL,
PRIMARY KEY (id),
-- zwei Personen dürfen nicht denselben Vor- und Nachnamen haben
CONSTRAINT unq_persons_first_name_last_name UNIQUE (first_name, last_name)
) ENGINE = InnoDB;
INSERT INTO persons (first_name, last_name, age) VALUES
('Marie', 'Pélissier', 42),
('Jacques', 'Bromard', 35),
('Philippe', 'Jandot', 58);
|
- Zeile 3: Der Zeichensatz [utf8mb4] akzeptiert alle Zeichen (Akzente, Emojis usw.). Die Kollation [utf8mb4_unicode_ci] vergleicht Zeichenketten ohne Rücksicht auf Groß- und Kleinschreibung und auf Akzente: Für [MySQL] sind [pelissier], und [Pélissier] gleich;
- Zeile 8: eine Versionsnummer, die bei jeder Änderung der Zeile erhöht wird (siehe „optimistisches Sperren“ weiter unten);
- Zeile 14: eine benannte Eindeutigkeitsbedingung: Die Datenbank lässt nicht zu, dass zwei Personen denselben Vor- und Nachnamen haben. Der Name dient dazu, den Fehler zu identifizieren.
9.1.2. Die Konfiguration
Die Datei [Example28.csproj]:
| <Project Sdk="Microsoft.NET.Sdk.Web">
<ItemGroup>
<!-- Entity Framework Core und sein MySQL- / MariaDB-Provider -->
<PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
</ItemGroup>
<ItemGroup>
<!-- das SQL-Skript ist keine Anwendungsdatei -->
<Content Remove="database\**" />
<None Include="database\**" />
</ItemGroup>
</Project>
|
- Zeile 5: der Provider [MySQL] für EF Core;
- Zeilen 10–11: Das SQL-Skript ist keine Anwendungsdatei: Es wird von den veröffentlichten Dateien ausgeschlossen.
Die Datei [appsettings.json]:
| {
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning",
"Microsoft.EntityFrameworkCore.Database.Command": "Warning"
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"DbPersons": "server=localhost;port=3306;database=dbpersons;user=root;password="
},
"MySql": {
"ServerVersion": "8.0.30-mysql"
}
}
|
- Zeile 6: EF Core protokolliert jeden an die Datenbank gesendeten SQL-Befehl auf der Ebene [Information]. Die Ebene [Warning] blendet sie aus; ersetzen Sie sie einfach durch [Information], um sie in der Konsole zu sehen;
- Zeilen 10–11: die Verbindungszeichenfolge: Server, Port, Datenbank, Benutzername, Passwort. Dies sind die Standardwerte von [Laragon] (Benutzername [root], kein Passwort);
- Zeile 14: die Version des [MySQL]-Servers. Der Provider [Pomelo] passt das von ihm erzeugte SQL an diese Version an. Beispielsweise würde eine Version von [MariaDB] als [10.11.0-mariadb] geschrieben.
Die Datei [Program.cs]:
| using System.Text.Encodings.Web;
using System.Text.Unicode;
using Example28.Dao;
using Example28.Data;
using Example28.Business;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.FileProviders;
var builder = WebApplication.CreateBuilder(args);
// die Datenbankverbindung: Verbindungszeichenfolge und Serverversion, aus appsettings.json gelesen
var connectionString = builder.Configuration.GetConnectionString("DbPersons")!;
var version = ServerVersion.Parse(builder.Configuration["MySql:ServerVersion"]!);
// AddDbContext: ein DbContext pro Anfrage (Lebensdauer Scoped)
builder.Services.AddDbContext<PersonsDbContext>(options => options.UseMySql(connectionString, version));
// die DAO- und die Geschäftsschicht: Scoped, wie der DbContext, den sie verwenden
builder.Services.AddScoped<PersonsDao>();
builder.Services.AddScoped<PersonsBusiness>();
builder.Services.AddControllersWithViews(options =>
options.ModelBindingMessageProvider.SetAttemptedValueIsInvalidAccessor((value, field) => $"The value [{value}] is not valid."));
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
var app = builder.Build();
app.UseStaticFiles();
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.MapControllers();
app.Run();
|
- Zeile 12: [GetConnectionString("DbPersons")] liest die Eigenschaft [DbPersons] aus dem Abschnitt [ConnectionStrings];
- Zeile 15: [AddDbContext] registriert [DbContext] (siehe unten) mit der Lebensdauer [Scoped]: einer pro Anfrage. [UseMySql] wählt den Provider [MySQL] aus;
- Zeilen 18–19: die DAO- und die Geschäftsschicht, die ebenfalls die Lebensdauer [Scoped] haben: Sie verwenden [DbContext], der nicht länger als eine einzelne Anfrage leben darf (siehe Kapitel 6);
- Zeile 22: eine Fehlermeldung für Konvertierungsfehler (siehe Beispiel 19).
9.1.3. Die Entität Person
Die Datei [Entities/Person.cs]:
| using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace Example28.Entities;
// eine Zeile der Tabelle [persons]
[Table("persons")]
public class Person
{
// der Primärschlüssel: ein Integer-Schlüssel wird konventionsgemäß von der Datenbank erzeugt
// (AUTO_INCREMENT); EF Core liest seinen Wert nach jedem INSERT zurück
[Key]
[Column("id")]
public int Id { get; set; }
// das optimistische Sperren: jedes UPDATE trägt die Bedingung "AND version = <gelesener Wert>"
[Column("version")]
[ConcurrencyCheck]
public int Version { get; set; } = 1;
[Column("first_name")]
[MaxLength(30)]
public string FirstName { get; set; } = "";
[Column("last_name")]
[MaxLength(30)]
public string LastName { get; set; } = "";
[Column("age")]
public int Age { get; set; }
}
|
- Zeile 7: Die Klasse [Person] entspricht der Tabelle [persons]: Jede Zeile der Tabelle wird zu einem [Person]-Objekt;
- Zeilen 12–14: der Primärschlüssel ([[Key]]). [[Column]] gibt den Spaltennamen an, der jeder Eigenschaft entspricht;
- Zeilen 18–19: die Versionsspalte. [[ConcurrencyCheck]] weist EF Core an, bei jedem [AND version = <value read>] die Bedingung [UPDATE] hinzuzufügen: Das ist das optimistische Sperren, das weiter unten erläutert wird;
- Zeile 22: die übrigen Spalten. [[MaxLength]] gibt die Spaltengröße an.
9.1.4. Der DbContext
Die Datei [Data/PersonsDbContext.cs]:
| using Example28.Entities;
using Microsoft.EntityFrameworkCore;
namespace Example28.Data;
// der DbContext: die Verbindung zur Datenbank und die Nachverfolgung der gelesenen Entitäten
public class PersonsDbContext(DbContextOptions<PersonsDbContext> options) : DbContext(options)
{
// die "Tabelle" der Personen: sie wird mit LINQ abgefragt
public DbSet<Person> Persons => Set<Person>();
// unmittelbar vor jedem Speichern: die Version jeder GEÄNDERTEN Person
// wird um 1 erhöht. Das erzeugte UPDATE vergleicht den ALTEN Wert:
// UPDATE persons SET ..., version = 2 WHERE id = 1 AND version = 1
public override Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
{
foreach (var entry in ChangeTracker.Entries<Person>())
{
if (entry.State == EntityState.Modified)
{
entry.Entity.Version++;
}
}
return base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
}
}
|
- Zeile 7: DbContext ist das zentrale Objekt von EF Core. Er stellt eine Arbeitssitzung mit der Datenbank dar: Er öffnet Verbindungen, sendet Abfragen und verfolgt die gelesenen Entitäten (er weiß, welche geändert wurden);
- Zeile 10: Ein [DbSet<Person>] stellt die Tabelle dar: Sie wird mit [LINQ] abgefragt, und Entitäten werden ihr hinzugefügt;
- Zeilen 15–24: [SaveChangesAsync] sendet alle ausstehenden Änderungen an die Datenbank. Die Methode ist so überschrieben, dass sie die Versionsnummer jeder geänderten Person erhöht. [ChangeTracker] verfolgt die Änderungen: Für jede verfolgte Entität kennt er ihren Status ([Added], [Modified], [Deleted], [Unchanged]). EF Core verwaltet, anders als [TypeORM], nicht von sich aus eine ganzzahlige Versionsspalte: Wir müssen sie selbst erhöhen.
9.1.5. Die DAO-Schicht
Die Datei [Dao/PersonsDao.cs]:
| using Example28.Data;
using Example28.Entities;
using Microsoft.EntityFrameworkCore;
namespace Example28.Dao;
// die DAO-Schicht: Abfragen, keine Geschäftsregel
public class PersonsDao(PersonsDbContext db)
{
// SELECT ... FROM persons ORDER BY last_name, first_name
public Task<List<Person>> ListAsync() =>
db.Persons.AsNoTracking().OrderBy(p => p.LastName).ThenBy(p => p.FirstName).ToListAsync();
// SELECT ... FROM persons WHERE id = @id LIMIT 1; null, falls nicht vorhanden
public Task<Person?> ReadAsync(int id) =>
db.Persons.FirstOrDefaultAsync(p => p.Id == id);
// eine Person mit gleichem Vor- und Nachnamen, außer [exceptId]
public Task<Person?> NamesakeAsync(string firstName, string lastName, int exceptId) =>
db.Persons.FirstOrDefaultAsync(p => p.FirstName == firstName && p.LastName == lastName && p.Id != exceptId);
// INSERT, wenn die Person neu ist (Id = 0), sonst UPDATE der geänderten Spalten
public async Task<Person> SaveAsync(Person person)
{
if (person.Id == 0)
{
db.Persons.Add(person);
}
await db.SaveChangesAsync();
return person;
}
// DELETE FROM persons WHERE id = @id, ohne die Person vorher zu lesen
public Task DeleteAsync(int id) =>
db.Persons.Where(p => p.Id == id).ExecuteDeleteAsync();
}
|
- Zeile 8: Das DAO erhält [DbContext] per Injektion;
- Zeilen 11–12: Eine [LINQ]-Abfrage, die von EF Core in SQL übersetzt wird. Vor dem Aufruf von [ToListAsync], der die Abfrage ausführt und die Liste zurückgibt, wird nichts an die Datenbank gesendet. [AsNoTracking()] gibt an, dass diese Entitäten nicht verändert werden: [DbContext] muss sie nicht verfolgen;
- Zeilen 15–16: das erste Element, das die Bedingung erfüllt, oder [null];
- Zeilen 19–20: Eine Person mit demselben Vor- und Nachnamen, außer [exceptId]: nützlich beim Ändern eines Datensatzes, der nicht mit sich selbst kollidieren darf. Der Vergleich wird von [MySQL] durchgeführt, also gemäß der Kollation der Datenbank: ohne Rücksicht auf Groß- und Kleinschreibung und auf Akzente;
- Zeilen 23–30: Eine neue Person ([Id] auf 0 gesetzt) wird zu [DbSet] hinzugefügt; [SaveChangesAsync] erzeugt dann ein [INSERT] und liest die von der Datenbank vergebene Kennung erneut ein. Eine von demselben [DbContext] gelesene und geänderte Person wird durch die Änderungsverfolgung erkannt: [SaveChangesAsync] erzeugt ein [UPDATE], das nur die geänderten Spalten enthält;
- Zeilen 34–35: [ExecuteDeleteAsync] sendet ein [DELETE] direkt an die Datenbank, ohne die Datensätze zuvor zu lesen.
Die DAO-Schicht enthält keine Regeln: nur Abfragen. Diese Methoden sind asynchron ([Task], [async] / [await]): Während die Datenbank arbeitet, wird der Thread freigegeben und bedient andere Anfragen.
9.1.6. Die Geschäftsschicht
Die Datei [Business/BusinessException.cs]:
| namespace Example28.Business;
// eine Geschäftsregel weist den Vorgang ab: die Meldung ist für den Benutzer bestimmt
public class BusinessException(string message) : Exception(message);
|
Eine [BusinessException] zeigt an, dass eine Geschäftsregel eine Operation abgelehnt hat. Das ist kein Programmfehler: Die Meldung ist für den Benutzer bestimmt.
Die Datei [Business/PersonsBusiness.cs]:
| using Example28.Dao;
using Example28.Data;
using Example28.Entities;
using Microsoft.EntityFrameworkCore;
using MySqlConnector;
namespace Example28.Business;
public record PersonData(string FirstName, string LastName, int Age);
// die GESCHÄFTSSCHICHT: die Geschäftsregeln, und nur sie
public class PersonsBusiness(PersonsDao dao, PersonsDbContext db)
{
private const string Namesake = "A person already has these first and last names.";
public Task<List<Person>> ListAsync() => dao.ListAsync();
public async Task<Person> ReadAsync(int id) =>
await dao.ReadAsync(id) ?? throw new BusinessException("This person does not exist (anymore).");
public Task<Person> AddAsync(PersonData data) =>
TransactionAsync(async () =>
{
// Regel 1: keine zwei Personen mit gleichem Vor- und Nachnamen
if (await dao.NamesakeAsync(data.FirstName, data.LastName, 0) is not null)
{
throw new BusinessException(Namesake);
}
var person = new Person { FirstName = data.FirstName, LastName = data.LastName, Age = data.Age };
return await dao.SaveAsync(person);
});
public Task<Person> EditAsync(int id, int version, PersonData data) =>
TransactionAsync(async () =>
{
var person = await ReadAsync(id);
// Regel 2: wir ändern keinen Datensatz, der inzwischen von jemand anderem geändert wurde
if (person.Version != version)
{
throw new BusinessException("This record has been modified meanwhile: reload it.");
}
if (await dao.NamesakeAsync(data.FirstName, data.LastName, id) is not null)
{
throw new BusinessException(Namesake);
}
person.FirstName = data.FirstName;
person.LastName = data.LastName;
person.Age = data.Age;
return await dao.SaveAsync(person);
});
public async Task<Person> DeleteAsync(int id)
{
var person = await ReadAsync(id);
await dao.DeleteAsync(id);
return person;
}
// [work] läuft innerhalb einer Transaktion: COMMIT bei Erfolg, ROLLBACK
// bei einer Ausnahme. Die Datenbankfehler werden zu BusinessExceptions
private async Task<R> TransactionAsync<R>(Func<Task<R>> work)
{
await using var transaction = await db.Database.BeginTransactionAsync(); // START TRANSACTION
try
{
var result = await work();
await transaction.CommitAsync(); // COMMIT
return result;
}
catch (DbUpdateConcurrencyException)
{
// das UPDATE "WHERE id = ... AND version = ..." hat keine Zeile geändert
throw new BusinessException("This record has been modified meanwhile: reload it.");
}
catch (DbUpdateException e) when (e.InnerException is MySqlException { ErrorCode: MySqlErrorCode.DuplicateKeyEntry } sqlError
&& sqlError.Message.Contains("unq_persons_first_name_last_name"))
{
// zwei gleichzeitige Hinzufügungen: die Eindeutigkeitsbedingung der Datenbank hat die zweite abgewiesen
throw new BusinessException(Namesake);
}
// jede andere Ausnahme nimmt ihren Lauf; die Transaktion, durch "await using"
// ohne COMMIT geschlossen, wird abgebrochen (ROLLBACK)
}
}
|
Gehen wir diesen Code Schritt für Schritt durch:
- Zeile 9: die Daten einer Person, wie sie von der Web-Schicht übergeben werden;
- Zeile 12: Die Geschäftsschicht verwendet das DAO und [DbContext] , um Transaktionen zu öffnen. Beide sind [Scoped]-Services: Während einer Anfrage erhalten das DAO und die Geschäftsschicht den selben [DbContext] und damit dieselbe Verbindung und dieselbe Transaktion. (Mit [TypeORM] musste das Transaktionsobjekt an jede Methode des DAO übergeben werden);
- Zeilen 18–19: Eine nicht vorhandene Person ist eine [BusinessException]. Der Operator [??] liefert einen Ersatzwert; [throw] kann als Ersatz dienen;
- Zeilen 21–30: das Hinzufügen innerhalb einer Transaktion. Regel: Keine zwei Personen dürfen denselben Vor- und Nachnamen haben. Dies wird vor dem Schreiben geprüft, um eine klare Meldung anzuzeigen;
- Zeilen 33–49: die Aktualisierung. Zusätzliche Regel: das optimistische Sperren (Zeilen 38–40). Das Änderungsformular hat die Version des Datensatzes so abgerufen, wie sie beim Öffnen des Formulars war. Hat sie sich in der Zwischenzeit geändert (ein anderer Benutzer hat denselben Datensatz geändert), wird die Aktualisierung abgelehnt, statt die Arbeit des anderen stillschweigend zu überschreiben;
- Zeilen 61–67: [BeginTransactionAsync] öffnet eine Transaktion ([START TRANSACTION]), und [CommitAsync] bestätigt sie ([COMMIT]). [await using] schließt die Transaktion beim Verlassen des Blocks, was auch geschieht: Wird sie ohne [COMMIT] geschlossen, wird sie zurückgerollt ([ROLLBACK]). So macht eine von [work] ausgelöste Ausnahme (auch eine [BusinessException]) alles rückgängig, was bis dahin getan wurde;
- Zeilen 70–73: Die zuvor erwähnte Versionsprüfung reicht nicht immer aus: Zwei Benutzer können denselben Datensatz gleichzeitig speichern, und beide bestehen die Prüfung. Das [UPDATE ... WHERE id = ... AND version = ...] des zweiten Benutzers ändert dann keine Zeile; EF Core erkennt dies und löst eine [DbUpdateConcurrencyException] aus, die zu derselben [BusinessException] wird;
- Zeilen 75–79: Ebenso bestehen zwei gleichzeitige Hinzufügungen derselben Person die Namensprüfung, doch die Eindeutigkeitsbedingung der Datenbank lässt sie nicht zu. Der Fehler [MySQL] (Code [DuplicateKeyEntry], Nr. 1062) tritt verschachtelt in einer [DbUpdateException] auf (Eigenschaft [InnerException]); seine Meldung enthält den Namen der Bedingung. Die Klausel [when] fängt die Ausnahme nur ab, wenn die Bedingung zutrifft. [is MySqlException { ErrorCode: ... } sqlError] ist ein Pattern-Filter: Er prüft den Typ und den Wert einer Eigenschaft und speichert das Objekt in einer Variablen.
9.1.7. Die Web-Schicht
Die Datei [Models/PersonForm.cs]:
| using System.ComponentModel.DataAnnotations;
namespace Example28.Models;
// die Formularfelder und ihre Einschränkungen (siehe Beispiel 19)
public class PersonForm
{
private string? firstName;
private string? lastName;
[Required(ErrorMessage = "The first name is required.")]
[MaxLength(30, ErrorMessage = "30 characters at most.")]
public string? FirstName { get => firstName; set => firstName = value?.Trim(); }
[Required(ErrorMessage = "The last name is required.")]
[MaxLength(30, ErrorMessage = "30 characters at most.")]
public string? LastName { get => lastName; set => lastName = value?.Trim(); }
[Required(ErrorMessage = "The age is required.")]
[Range(0, 150, ErrorMessage = "The age must be between 0 and 150.")]
public int? Age { get; set; }
// die Version des Datensatzes, in einem versteckten Feld mitgeführt (nur beim Bearbeiten)
public int? Version { get; set; }
}
// das Modell der Formular-View
public class FormView
{
public required string Title { get; init; } // "Add a person"...
public required string Action { get; init; } // die Adresse, an die das Formular gesendet wird
public PersonForm Values { get; init; } = new();
public Dictionary<string, string> Errors { get; init; } = new(StringComparer.OrdinalIgnoreCase);
}
// das Modell der Partial View _Field
public record FieldModel(string Name, string Label, string Type, string? Value, string? Error);
|
Das Formular und seine Einschränkungen (siehe Beispiel 19), einschließlich der Datensatzversion (Zeile 24); das Formular-View-Template, das zum Hinzufügen und Ändern verwendet wird (anderer Titel und andere Übermittlungsadresse, [Action]); das partielle View-Template [_Field] (siehe Beispiel 19).
Die Datei [Controllers/PersonsController.cs]:
| using Example28.Business;
using Example28.Models;
using Microsoft.AspNetCore.Mvc;
namespace Example28.Controllers;
// die WEB-Schicht: sie kennt nur die Geschäftsschicht
public class PersonsController(PersonsBusiness business) : Controller
{
[HttpGet("/")]
public IActionResult Home() => RedirectToAction(nameof(List));
[HttpGet("persons")]
public async Task<IActionResult> List()
{
return View(await business.ListAsync());
}
[HttpGet("persons/add")]
public IActionResult AddForm() => Form(BuildView("Add a person", "/persons/add", new()));
[HttpPost("persons/add")]
public async Task<IActionResult> Add(PersonForm input)
{
var view = BuildView("Add a person", "/persons/add", input);
if (!ModelState.IsValid)
{
return Form(view);
}
try
{
var person = await business.AddAsync(new PersonData(input.FirstName!, input.LastName!, input.Age!.Value));
TempData["Success"] = $"{person.FirstName} {person.LastName} has been added.";
return RedirectToAction(nameof(List));
}
catch (BusinessException e)
{
// eine Geschäftsregel lehnt ab: wir zeigen das Formular erneut an, die Meldung unten auf der Seite
return Form(view, e.Message);
}
}
[HttpGet("persons/{id:int}/edit")]
public async Task<IActionResult> EditForm(int id)
{
try
{
var p = await business.ReadAsync(id);
var values = new PersonForm { FirstName = p.FirstName, LastName = p.LastName, Age = p.Age, Version = p.Version };
return Form(BuildView("Edit a person", $"/persons/{id}/edit", values));
}
catch (BusinessException e)
{
TempData["Error"] = e.Message;
return RedirectToAction(nameof(List));
}
}
[HttpPost("persons/{id:int}/edit")]
public async Task<IActionResult> Edit(int id, PersonForm input)
{
var view = BuildView("Edit a person", $"/persons/{id}/edit", input);
if (!ModelState.IsValid)
{
return Form(view);
}
try
{
var data = new PersonData(input.FirstName!, input.LastName!, input.Age!.Value);
var person = await business.EditAsync(id, input.Version ?? 0, data);
TempData["Success"] = $"{person.FirstName} {person.LastName} has been edited.";
return RedirectToAction(nameof(List));
}
catch (BusinessException e)
{
return Form(view, e.Message);
}
}
[HttpPost("persons/{id:int}/delete")]
public async Task<IActionResult> Delete(int id)
{
try
{
var person = await business.DeleteAsync(id);
TempData["Success"] = $"{person.FirstName} {person.LastName} has been deleted.";
}
catch (BusinessException e)
{
// kein erneut anzuzeigendes Formular: der Fehler reist ebenfalls in TempData mit
TempData["Error"] = e.Message;
}
return RedirectToAction(nameof(List));
}
// das Modell der Formular-View, mit den ModelState-Fehlern nach Feldern sortiert
private FormView BuildView(string title, string action, PersonForm values) => new()
{
Title = title,
Action = action,
Values = values,
Errors = ModelState
.Where(c => c.Value!.Errors.Count > 0)
.ToDictionary(c => c.Key, c => c.Value!.Errors[0].ErrorMessage, StringComparer.OrdinalIgnoreCase),
};
private ViewResult Form(FormView view, string? error = null)
{
ViewData["Error"] = error;
return View("Form", view);
}
}
|
Kommentieren wir diesen Code:
- Zeile 8: Der Controller kennt nur die Geschäftsschicht;
- Zeile 11: Die Wurzel der Website leitet auf die Liste um;
- Zeilen 14–16: eine asynchrone Aktion: Sie gibt einen [Task<IActionResult>] zurück und wartet ([await]), bis die Liste aus der Datenbank gelesen ist;
- Zeilen 23–39: das Hinzufügen in drei Schritten: Formularvalidierung (Fehler: Seite neu laden), Aufruf der Geschäftsschicht (Erfolg: Meldung in [TempData] und Umleitung, siehe Beispiel 20), [BusinessException] (erneute Anzeige mit der Meldung am Seitenende). Eine andere Ausnahme wird nicht abgefangen: Das ist eine Anomalie, die zu einem 500-Fehler führt;
- Zeilen 44–55: das Änderungsformular, vorausgefüllt mit dem aus der Datenbank abgerufenen Datensatz einschließlich seiner Version;
- Zeilen 60–76: derselbe Ablauf wie beim Hinzufügen; die vom Formular zurückgegebene Version wird an die Geschäftsschicht übergeben;
- Zeilen 81–93: das Löschen. Es gibt kein Formular, das erneut angezeigt werden müsste: Eventuelle Fehler werden ebenfalls über [TempData] weitergereicht;
- Zeilen 97–104: das Formular-View-Template, mit den nach Feldern sortierten Fehlern aus [ModelState] (siehe Beispiel 19).
Die Datei [Views/Persons/Form.cshtml]:
| @model FormView
@{
string? Error(string field) => Model.Errors.GetValueOrDefault(field);
}
<h1 class="h3">@Model.Title</h1>
<form method="post" action="@Model.Action" novalidate>
@* die Version des gelesenen Datensatzes: sie kommt mit dem Formular zurück *@
<input type="hidden" name="version" value="@Model.Values.Version">
<partial name="_Field" model='new FieldModel("firstName", "First name", "text", Model.Values.FirstName, Error("firstName"))' />
<partial name="_Field" model='new FieldModel("lastName", "Last name", "text", Model.Values.LastName, Error("lastName"))' />
<partial name="_Field" model='new FieldModel("age", "Age", "number", Model.Values.Age?.ToString(), Error("age"))' />
<button class="btn btn-primary" type="submit">Save</button>
<a class="btn btn-link" href="/persons">Cancel</a>
</form>
|
- Zeile 8: das versteckte Feld, das die Datensatzversion überträgt. Die View wird zum Hinzufügen und zum Ändern verwendet: Ihr Titel und die Übermittlungs-URL ([action]) werden vom Controller geliefert.
Die Datei [Views/Shared/_Layout.cshtml]:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Persons</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3" style="max-width: 40rem">
@* die Erfolgsmeldung (TempData, nach einer Umleitung): am Seitenanfang *@
@if (TempData["Success"] is string success)
{
<div class="alert alert-success" role="status">@success</div>
}
@RenderBody()
@* der Fehler: aus der aktuellen Anfrage (ViewData) oder von vor der Umleitung (TempData) *@
@if ((ViewData["Error"] ?? TempData["Error"]) is string error)
{
<div class="error-area" role="alert">@error</div>
}
</div>
<partial name="_Confirmation" />
<script src="/js/app.js"></script>
</body>
</html>
|
- Zeile 12: die Erfolgsmeldung am Seitenanfang;
- Zeile 18: die Fehlermeldung am Seitenende: entweder die der aktuellen Anfrage ([ViewData]) oder die vor einer Umleitung angezeigte ([TempData]).
Die Views [List.cshtml] und [_Field.cshtml] sowie das Bestätigungsskript sind dieselben wie in den Beispielen 19 und 21.
9.1.8. Ausführung
Wenn die Werte in [appsettings.json] ungeeignet sind (etwa ein Passwort für [root]), können sie – ohne die Datei zu ändern – durch Umgebungsvariablen ersetzt werden: Das Abschnittstrennzeichen [:] wird dabei als [__] (zwei Unterstriche) geschrieben. Unter [Windows] ([PowerShell]):
| $env:ConnectionStrings__DbPersons="server=localhost;database=dbpersons;user=root;password=secret"; dotnet run
|
Die Liste, aufgerufen über die URL http://localhost:5000/:

Ein ungültiges Formular:

Ein Namensduplikat: Die Geschäftsregel erkennt es. [MySQL], das gemäß der Kollation der Datenbank vergleicht, würde auch [marie pelissier] ablehnen – in Kleinbuchstaben und ohne Akzente geschrieben:

Ein erfolgreiches Hinzufügen:

Ist die Protokollierungsebene [Information] für [Microsoft.EntityFrameworkCore.Database.Command] gesetzt, zeigt die Konsole für jede SQL-Anfrage den Anfragetext, ihre Parameter (aus Vorsicht standardmäßig ausgeblendet) und ihre Ausführungszeit an: Wir sehen die Transaktion, die Suche nach einem Namensduplikat ([SELECT ... LIMIT 1]), das [INSERT] mit anschließendem Lesen der vergebenen Kennung, das [COMMIT] und dann, nach der Umleitung, das Lesen der Liste ([SELECT ... ORDER BY]).
Das optimistische Sperren: Zwei Formulare sind für denselben Datensatz geöffnet; das erste wird gespeichert (die Version steigt auf 2); das zweite, das noch Version 1 hat, wird abgelehnt:

Löschen, mit Bestätigung:

