Skip to content

9. 分层架构与数据访问

前面的示例将数据保存在内存中。真实的应用程序把数据存储在数据库中,并按层 来组织(见引言中的示意图):

  • Web 层(控制器、视图):读取请求、调用业务层、选择视图;
  • 业务层:业务规则;
  • DAO ([Data Access Object])层:数据库查询。

每一层只了解它下面的那一层,并且尽可能少地了解其细节:Web 层不了解 SQL,业务层不了解 HTML。这种分离使每一层都更易于理解、测试和演进。示例 28 将其应用于人员列表的管理:它是案例研究中医生和客户管理的缩小版。

数据库访问由 Entity Framework Core (EF Core)负责,它是 [Object-Relational Mapper] 的 [.NET] 对象关系映射器(ORM):它将 [C#] 类(即实体)映射到数据库表,将用 [LINQ] 编写的查询翻译成 SQL,并将检索到的行转换为对象。EF Core 通过提供程序 ([provider])与每种类型的数据库通信:对于 [MySQL],使用 [NuGet] 包,它包含 [Pomelo.EntityFrameworkCore.MySql],而后者又包含 EF Core 和 [MySqlConnector] 驱动程序。

9.1. 示例 28:三层人员管理系统

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. 数据库

数据库 [dbpersons] 由一个 SQL 脚本创建。使用 [Laragon],你可以在例如 [HeidiSQL] 工具中运行它(“文件”菜单 / 运行 SQL 文件),或者从命令行运行:

mysql -u root < database/dbpersons.sql

文件 [database/dbpersons.sql]:

-- database of example 28: a single table, [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),
  -- two persons cannot have the same first and last names
  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);
  • 第 3 行:字符集 [utf8mb4] 接受所有字符(带重音的字符、表情符号等)。排序规则 [utf8mb4_unicode_ci] 在比较字符串时不区分大小写和重音:对于 [MySQL],[pelissier] 和 [Pélissier] 是相等的;
  • 第 8 行:版本号,每次修改该行时递增(见下文的“乐观锁”);
  • 第 14 行:一个具名的唯一性约束:数据库不允许存在姓和名都相同的两个人。该约束的名称将用于识别错误。

9.1.2. 配置

文件 [Example28.csproj]:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <ItemGroup>
    <!-- Entity Framework Core 及其 MySQL / MariaDB 提供程序 -->
    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
  </ItemGroup>

  <ItemGroup>
    <!-- SQL 脚本不是应用程序文件 -->
    <Content Remove="database\**" />
    <None Include="database\**" />
  </ItemGroup>

</Project>
  • 第 5 行:EF Core 的 [MySQL] 提供程序;
  • 第 10–11 行:SQL 脚本不是应用程序文件:它被排除在发布的文件之外。

文件 [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"
  }
}
  • 第 6 行:EF Core 以 [Information] 级别记录发送到数据库的每条 SQL 命令。[Warning] 级别会屏蔽它们;只需将其替换为 [Information] 即可在控制台中查看它们;
  • 第 10–11 行:连接字符串:服务器、端口、数据库、用户名、密码。这些是 [Laragon] 的默认值(用户名 [root],无密码);
  • 第 14 行:[MySQL] 服务器版本。提供程序 [Pomelo] 会根据该版本调整它生成的 SQL。例如,[MariaDB] 的版本应写成 [10.11.0-mariadb]。

文件 [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);

// 数据库连接:连接字符串和服务器版本,从 appsettings.json 读取
var connectionString = builder.Configuration.GetConnectionString("DbPersons")!;
var version = ServerVersion.Parse(builder.Configuration["MySql:ServerVersion"]!);
// AddDbContext:每个请求一个 DbContext(Scoped 生命周期)
builder.Services.AddDbContext<PersonsDbContext>(options => options.UseMySql(connectionString, version));

// DAO 层和业务层:Scoped,与它们使用的 DbContext 一致
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();
  • 第 12 行:[GetConnectionString("DbPersons")] 从 [ConnectionStrings] 节中读取 [DbPersons] 属性;
  • 第 15 行:[AddDbContext] 注册 [DbContext] (见下文),生存期为 [Scoped]:每个请求一个。[UseMySql] 选择提供程序 [MySQL];
  • 第 18–19 行:DAO 层和业务层,它们的生存期同样是 [Scoped]:它们使用 [DbContext],而 DbContext 的存活时间不能超过单个请求(见第 6 章);
  • 第 22 行:转换错误消息(见示例 19)。

9.1.3. Person 实体

文件 [Entities/Person.cs]:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Example28.Entities;

// [persons] 表的一行
[Table("persons")]
public class Person
{
    // 主键:整数键按约定由数据库生成
    // (AUTO_INCREMENT);EF Core 在每次 INSERT 之后读回其值
    [Key]
    [Column("id")]
    public int Id { get; set; }

    // 乐观锁:每个 UPDATE 都带有条件 "AND version = <读取到的值>"
    [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; }
}
  • 第 7 行:类 [Person] 对应表 [persons]:该表的每一行都将是一个 [Person] 对象;
  • 第 12–14 行:主键([[Key]])。[[Column]] 指定与每个属性对应的列名;
  • 第 18–19 行:版本列。[[ConcurrencyCheck]] 指示 EF Core 在每条 [AND version = <value read>] 语句中添加条件 [UPDATE]:这就是乐观锁,下文将进一步解释;
  • 第 22 行:其他列。[[MaxLength]] 指定列的大小。

9.1.4. DbContext

文件 [Data/PersonsDbContext.cs]:

using Example28.Entities;
using Microsoft.EntityFrameworkCore;

namespace Example28.Data;

// DbContext:到数据库的连接,以及对已读取实体的跟踪
public class PersonsDbContext(DbContextOptions<PersonsDbContext> options) : DbContext(options)
{
    // 人员的“表”:使用 LINQ 查询
    public DbSet<Person> Persons => Set<Person>();

    // 每次保存之前:每个被修改的人员的 version
    // 加 1。生成的 UPDATE 比较的是旧值:
    //   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);
    }
}
  • 第 7 行:DbContext 是 EF Core 的核心对象。它代表与数据库的一个工作会话:它打开连接、发送查询,并跟踪它所读取的实体(它知道哪些实体已被修改);
  • 第 10 行:[DbSet<Person>] 代表该表:使用 [LINQ] 对它进行查询,并向其中添加实体;
  • 第 15–24 行:[SaveChangesAsync] 将所有待处理的更改发送到数据库。这里重新定义了它,以便为每个被修改的人员递增版本号。[ChangeTracker] 跟踪更改:对每个被跟踪的实体,它都知道其状态([Added]、[Modified]、[Deleted]、[Unchanged])。与 [TypeORM] 不同,EF Core 不会自行管理整数版本列:需要由我们来递增它。

9.1.5. DAO 层

文件 [Dao/PersonsDao.cs]:

using Example28.Data;
using Example28.Entities;
using Microsoft.EntityFrameworkCore;

namespace Example28.Dao;

// DAO 层:查询,不含业务规则
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
    public Task<Person?> ReadAsync(int id) =>
        db.Persons.FirstOrDefaultAsync(p => p.Id == id);

    // 与 [exceptId] 之外的某个人员同名同姓
    public Task<Person?> NamesakeAsync(string firstName, string lastName, int exceptId) =>
        db.Persons.FirstOrDefaultAsync(p => p.FirstName == firstName && p.LastName == lastName && p.Id != exceptId);

    // 人员是新的(Id = 0)则 INSERT,否则对被修改的列执行 UPDATE
    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,无需先读取该人员
    public Task DeleteAsync(int id) =>
        db.Persons.Where(p => p.Id == id).ExecuteDeleteAsync();
}
  • 第 8 行:DAO 通过注入接收 [DbContext] ;
  • 第 11–12 行:一个 [LINQ] 查询,由 EF Core 翻译成 SQL。在调用 [ToListAsync] 之前,不会向数据库发送任何内容,该调用执行查询并返回列表。[AsNoTracking()] 表示这些实体不会被修改:[DbContext] 无需跟踪它们;
  • 第 15–16 行:返回第一个满足条件的元素,否则返回 [null];
  • 第 19–20 行:查找与给定姓和名相同、但不是 [exceptId] 的人员:这在修改记录时很有用,因为记录不得与自身冲突。比较由 [MySQL] 执行,因此遵循数据库的排序规则:不区分大小写和重音;
  • 第 23–30 行:新人员([Id] 设为 0)被添加到 [DbSet] 中;[SaveChangesAsync] 随后创建一条 [INSERT] 语句,并重新读取数据库分配的标识符。由同一个 [DbContext] 读取并被修改的人员会被更改跟踪检测到:[SaveChangesAsync] 创建一条只包含被修改列的 [UPDATE] 语句;
  • 第 34–35 行:[ExecuteDeleteAsync] 直接向数据库发送 [DELETE] 语句,而不先读取记录。

DAO 层不包含任何规则:只有查询。这些方法是异步的 ([Task]、[async] / [await]):数据库处理期间,线程被释放出来为其他请求服务。

9.1.6. 业务层

文件 [Business/BusinessException.cs]:

1
2
3
4
namespace Example28.Business;

// 某条业务规则拒绝该操作:消息面向用户
public class BusinessException(string message) : Exception(message);

[BusinessException] 表示某条业务规则拒绝了一项操作。这不是程序错误:该消息是给用户看的。

文件 [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);

// 业务层:业务规则,且仅限业务规则
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 () =>
        {
            // 规则 1:不允许两个人员的名和姓都相同
            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);
            // 规则 2:不修改在此期间已被他人修改的记录
            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] 在事务中运行:成功则 COMMIT,抛出异常则 ROLLBACK。
    // 数据库错误会转换为 BusinessException
    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)
        {
            // UPDATE "WHERE id = ... AND version = ..." 没有修改任何行
            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"))
        {
            // 两个同时发生的添加:数据库的唯一性约束拒绝了第二个
            throw new BusinessException(Namesake);
        }
        // 任何其他异常继续向外传播;事务由 "await using" 关闭
        // 而未 COMMIT,因此被取消(ROLLBACK)
    }
}

让我们分析这段代码:

  • 第 9 行:一个人员的数据,由 Web 层传入;
  • 第 12 行:业务层使用 DAO 和 [DbContext] 来开启事务。两者都是 [Scoped] 服务:在一个请求期间,DAO 和业务层收到的是同一个 [DbContext],因此也是同一个连接和同一个事务。(使用 [TypeORM] 时,必须把事务对象传给 DAO 的每个方法);
  • 第 18–19 行:不存在的人员会引发 [BusinessException]。[??] 运算符提供一个替代值;[throw] 可以充当这个替代值;
  • 第 21–30 行:添加,在事务中进行。规则:不允许有两个人的姓和名都相同。这在写入之前检查,以便显示清晰的消息;
  • 第 33–49 行:更新。附加规则:乐观锁(第 38–40 行)。更新表单取回的是打开表单时记录的版本。如果在此期间它已发生变化(另一个用户修改了同一条记录),更新会被拒绝,而不是悄悄地覆盖该用户的工作成果;
  • 第 61–67 行:[BeginTransactionAsync] 开启一个事务([START TRANSACTION]),而 [CommitAsync] 提交它([COMMIT])。[await using] 会在退出代码块时关闭事务,无论发生什么:如果在没有 [COMMIT] 的情况下关闭,则会回滚([ROLLBACK])。因此,[work] 抛出的异常(包括 [BusinessException])会回滚已完成的所有操作;
  • 第 70–73 行:前面提到的版本检查并不总是足够:两个用户可能同时保存同一条记录,并且都通过检查。第二个用户的 [UPDATE ... WHERE id = ... AND version = ...] 语句于是不会修改任何行;EF Core 会检测到这一点并抛出 [DbUpdateConcurrencyException],它会被转换为同样的 [BusinessException];
  • 第 75–79 行:同样,同一个人被同时添加两次时,两次都能通过重名检查,但数据库的唯一性约束不允许它们都被添加。[MySQL] 错误(代码 [DuplicateKeyEntry],编号 1062)嵌套在 [DbUpdateException] 中(属性 [InnerException]);其消息中包含约束的名称。子句 [when] 仅在条件为真时才拦截该异常。[is MySqlException { ErrorCode: ... } sqlError] 是一个模式过滤器:它测试类型和某个属性的值,并将该对象存入变量。

9.1.7. Web 层

文件 [Models/PersonForm.cs]:

using System.ComponentModel.DataAnnotations;

namespace Example28.Models;

// 表单字段及其约束(见示例 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; }

    // 记录的版本,由隐藏字段携带(仅用于编辑)
    public int? Version { get; set; }
}

// 表单视图的模型
public class FormView
{
    public required string Title { get; init; }  // "Add a person"……
    public required string Action { get; init; } // 表单提交到的地址
    public PersonForm Values { get; init; } = new();
    public Dictionary<string, string> Errors { get; init; } = new(StringComparer.OrdinalIgnoreCase);
}

// 局部视图 _Field 的模型
public record FieldModel(string Name, string Label, string Type, string? Value, string? Error);

表单及其约束(见示例 19),包括记录的版本(第 24 行);表单视图模板,用于添加和修改记录(标题和提交地址不同,[Action]);局部视图模板 [_Field] (见示例 19)。

文件 [Controllers/PersonsController.cs]:

using Example28.Business;
using Example28.Models;
using Microsoft.AspNetCore.Mvc;

namespace Example28.Controllers;

// Web 层:它只认识业务层
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)
        {
            // 某条业务规则拒绝:我们再次显示表单,消息显示在页面底部
            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)
        {
            // 没有可再次显示的表单:错误也通过 TempData 传递
            TempData["Error"] = e.Message;
        }
        return RedirectToAction(nameof(List));
    }

    // 表单视图的模型,ModelState 错误按字段排序
    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);
    }
}

让我们对这段代码做些说明:

  • 第 8 行:控制器只知道业务层;
  • 第 11 行:站点根路径重定向到列表;
  • 第 14–16 行:一个异步操作:它返回 [Task<IActionResult>] ,并等待([await])从数据库读取列表;
  • 第 23–39 行:添加,分三步:表单验证(出错:重新加载页面)、调用业务层(成功:消息存入 [TempData] 并重定向,见示例 20)、[BusinessException](带着页面底部的消息重新显示)。其他异常不会被捕获:这属于异常情况,将导致 500 错误;
  • 第 44–55 行:更新表单,预先填入从数据库取回的记录,包括其版本;
  • 第 60–76 行:与添加相同的流程;表单返回的版本被传递给业务层;
  • 第 81–93 行:删除。没有可重新显示的表单:任何错误同样通过 [TempData] 传递;
  • 第 97–104 行:表单视图模板,其中来自 [ModelState] 的错误按字段排序(见示例 19)。

文件 [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>
  @* the version of the record read: it will come back with the form *@
  <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>
  • 第 8 行:携带记录版本的隐藏字段。该视图同时用于添加和修改记录:其标题和提交 URL([action])由控制器提供。

文件 [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">
    @* the success message (TempData, after a redirect): at the top *@
    @if (TempData["Success"] is string success)
    {
      <div class="alert alert-success" role="status">@success</div>
    }
    @RenderBody()
    @* the error: from the current request (ViewData) or from before the redirect (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>
  • 第 12 行:成功消息,位于页面顶部;
  • 第 18 行:错误消息,位于页面底部:要么是当前请求的消息([ViewData]),要么是重定向之前显示的消息([TempData])。

视图 [List.cshtml] and [_Field.cshtml]以及确认脚本,与示例 19 和示例 21 中的相同。

9.1.8. 执行

如果 [appsettings.json] 中的值不合适(例如 [root] 的密码),可以在不修改该文件的情况下用环境变量替换它们:节分隔符 [:] 写成 [__] (两个下划线)。在 [Windows] ([PowerShell])下:

$env:ConnectionStrings__DbPersons="server=localhost;database=dbpersons;user=root;password=secret"; dotnet run

列表,从 URL http://localhost:5000/ 开始:

Image

无效的表单:

Image

同名者:业务规则会检测到它。[MySQL] 按数据库的排序规则进行比较,同样会拒绝 [marie pelissier]——小写且不带重音:

Image

添加成功:

Image

将 [Information] 日志级别设置给 [Microsoft.EntityFrameworkCore.Database.Command] 后,控制台会为每条 SQL 请求显示请求文本、其参数(出于谨慎,默认隐藏)及其执行时间:我们可以看到事务、同名查找([SELECT ... LIMIT 1])、[INSERT] 以及随后对所分配标识符的读取、[COMMIT],然后在重定向之后,是对列表的读取([SELECT ... ORDER BY])。

乐观锁:两个表单打开的是同一条记录;第一个被保存(版本升为 2);第二个仍持有版本 1,因而被拒绝:

Image

删除,带确认:

Image

Image