Skip to content

9. Arquitetura em camadas e acesso a dados

Os exemplos anteriores mantinham seus dados na memória. Uma aplicação real os armazena em um banco de dados e é organizada em camadas (veja o diagrama na introdução):

  • a camada web (controllers, views): lê a requisição, chama a camada de negócio, seleciona a view;
  • a camada de negócio: regras de negócio;
  • a camada DAO ([Data Access Object]): consultas ao banco de dados.

Cada camada conhece apenas a camada abaixo dela, e o mínimo possível de detalhes sobre ela: a camada web desconhece o SQL, e a camada de negócio desconhece o HTML. Essa separação torna cada camada mais fácil de entender, testar e evoluir. O Exemplo 28 aplica isso ao gerenciamento de uma lista de pessoas: é, em escala menor, o gerenciamento de médicos e clientes do estudo de caso.

O acesso ao banco de dados é feito pelo Entity Framework Core (EF Core), o ORM ([Object-Relational Mapper]) do [.NET]: ele mapeia classes [C#] (as entidades) para as tabelas do banco de dados, traduz consultas escritas em [LINQ] para SQL e transforma as linhas recuperadas em objetos. O EF Core se comunica com cada tipo de banco de dados por meio de um provider ([provider]): para o [MySQL], o pacote [NuGet] [Pomelo.EntityFrameworkCore.MySql], que por sua vez inclui o EF Core e o driver [MySqlConnector].

9.1. Exemplo 28: um sistema de gerenciamento de pessoas em três camadas

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. O banco de dados

O banco de dados [dbpersons] é criado por um script SQL. Usando o [Laragon], você pode executá-lo, por exemplo, na ferramenta [HeidiSQL] (menu File / Run a SQL file), ou pela linha de comando:

mysql -u root < database/dbpersons.sql

O arquivo [database/dbpersons.sql]:

-- banco de dados do exemplo 28: uma única tabela, [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),
  -- duas pessoas não podem ter o mesmo nome e sobrenome
  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);
  • Linha 3: o conjunto de caracteres [utf8mb4] aceita todos os caracteres (acentos, emojis etc.). A collation [utf8mb4_unicode_ci] compara cadeias sem distinguir maiúsculas de minúsculas nem acentos: para o [MySQL], [pelissier], e [Pélissier] são iguais;
  • linha 8: um número de versão, incrementado a cada vez que a linha é modificada (veja “bloqueio otimista”, adiante);
  • linha 14: uma restrição de unicidade nomeada: o banco de dados não permite duas pessoas com o mesmo nome e sobrenome. O nome será usado para identificar o erro.

9.1.2. A configuração

O arquivo [Example28.csproj]:

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

  <ItemGroup>
    <!-- Entity Framework Core e seu provider MySQL / MariaDB -->
    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
  </ItemGroup>

  <ItemGroup>
    <!-- o script SQL não é um arquivo da aplicação -->
    <Content Remove="database\**" />
    <None Include="database\**" />
  </ItemGroup>

</Project>
  • linha 5: o provider [MySQL] para o EF Core;
  • Linhas 10–11: o script SQL não é um arquivo da aplicação: ele é excluído dos arquivos publicados.

O arquivo [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"
  }
}
  • linha 6: o EF Core registra em log cada comando SQL enviado ao banco de dados no nível [Information]. O nível [Warning] os oculta; basta substituí-lo por [Information] para vê-los no console;
  • linhas 10–11: a string de conexão: servidor, porta, banco de dados, nome de usuário, senha. Esses são os valores padrão do [Laragon] (usuário [root], sem senha);
  • linha 14: a versão do servidor [MySQL]. O provider [Pomelo] adapta o SQL que gera a essa versão. Por exemplo, uma versão do [MariaDB] seria escrita como [10.11.0-mariadb].

O arquivo [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);

// a conexão com o banco de dados: string de conexão e versão do servidor, lidas de appsettings.json
var connectionString = builder.Configuration.GetConnectionString("DbPersons")!;
var version = ServerVersion.Parse(builder.Configuration["MySql:ServerVersion"]!);
// AddDbContext: um DbContext por requisição (tempo de vida Scoped)
builder.Services.AddDbContext<PersonsDbContext>(options => options.UseMySql(connectionString, version));

// as camadas DAO e de negócio: Scoped, como o DbContext que elas usam
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();
  • linha 12: [GetConnectionString("DbPersons")] lê a propriedade [DbPersons] da seção [ConnectionStrings];
  • linha 15: [AddDbContext] registra o [DbContext] (veja adiante), com um tempo de vida [Scoped]: um por requisição. [UseMySql] seleciona o provider [MySQL];
  • linhas 18–19: as camadas DAO e de negócio, que também têm tempo de vida [Scoped]: elas usam o [DbContext], que não pode durar mais do que uma única requisição (veja o Capítulo 6);
  • linha 22: uma mensagem de erro de conversão (veja o Exemplo 19).

9.1.3. A entidade Person

O arquivo [Entities/Person.cs]:

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

namespace Example28.Entities;

// uma linha da tabela [persons]
[Table("persons")]
public class Person
{
    // a chave primária: uma chave inteira é, por convenção, gerada pelo banco de dados
    // (AUTO_INCREMENT); o EF Core lê seu valor de volta após cada INSERT
    [Key]
    [Column("id")]
    public int Id { get; set; }

    // o bloqueio otimista: cada UPDATE carrega a condição "AND version = <valor lido>"
    [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; }
}
  • linha 7: a classe [Person] corresponde à tabela [persons]: cada linha da tabela será um objeto [Person];
  • Linhas 12–14: a chave primária ([[Key]]). [[Column]] especifica o nome da coluna correspondente a cada propriedade;
  • linhas 18–19: a coluna de versão. [[ConcurrencyCheck]] instrui o EF Core a adicionar a condição [AND version = <value read>] a cada [UPDATE]: este é o bloqueio otimista, explicado mais adiante;
  • linha 22: as demais colunas. [[MaxLength]] especifica o tamanho da coluna.

9.1.4. O DbContext

O arquivo [Data/PersonsDbContext.cs]:

using Example28.Entities;
using Microsoft.EntityFrameworkCore;

namespace Example28.Data;

// o DbContext: a conexão com o banco de dados e o rastreamento das entidades lidas
public class PersonsDbContext(DbContextOptions<PersonsDbContext> options) : DbContext(options)
{
    // a "tabela" de pessoas: é consultada com LINQ
    public DbSet<Person> Persons => Set<Person>();

    // logo antes de cada gravação: a versão de toda pessoa MODIFICADA
    // é incrementada em 1. O UPDATE gerado compara o valor ANTIGO:
    //   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);
    }
}
  • linha 7: o DbContext é o objeto central do EF Core. Ele representa uma sessão de trabalho com o banco de dados: abre conexões, envia consultas e rastreia as entidades que leu (ele sabe quais foram modificadas);
  • Linha 10: um [DbSet<Person>] representa a tabela: ela é consultada por meio de [LINQ], e entidades são adicionadas a ela;
  • Linhas 15–24: [SaveChangesAsync] envia todas as alterações pendentes ao banco de dados. Ele é redefinido para incrementar o número de versão de cada pessoa modificada. [ChangeTracker] rastreia as alterações: para cada entidade rastreada, ele conhece seu estado ([Added], [Modified], [Deleted], [Unchanged]). O EF Core, ao contrário do [TypeORM], não gerencia por conta própria uma coluna de versão inteira: cabe a nós incrementá-la.

9.1.5. A camada DAO

O arquivo [Dao/PersonsDao.cs]:

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

namespace Example28.Dao;

// a camada DAO: consultas, sem regra de negócio
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 se não existir
    public Task<Person?> ReadAsync(int id) =>
        db.Persons.FirstOrDefaultAsync(p => p.Id == id);

    // uma pessoa com os mesmos nome e sobrenome, diferente de [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 se a pessoa for nova (Id = 0), UPDATE das colunas modificadas caso contrário
    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, sem ler a pessoa antes
    public Task DeleteAsync(int id) =>
        db.Persons.Where(p => p.Id == id).ExecuteDeleteAsync();
}
  • linha 8: o DAO recebe o [DbContext] por injeção;
  • Linhas 11–12: uma consulta [LINQ], traduzida para SQL pelo EF Core. Nada é enviado ao banco de dados antes da chamada a [ToListAsync], que executa a consulta e retorna a lista. [AsNoTracking()] indica que essas entidades não serão modificadas: [DbContext] não precisa rastreá-las;
  • linhas 15–16: o primeiro elemento que satisfaz a condição, ou [null];
  • Linhas 19–20: uma pessoa com o mesmo nome e sobrenome, diferente de [exceptId]: útil para modificar um registro, que não deve entrar em conflito consigo mesmo. A comparação é feita pelo [MySQL], portanto de acordo com a collation do banco de dados: sem distinguir maiúsculas de minúsculas nem acentos;
  • Linhas 23–30: uma nova pessoa ([Id] igual a 0) é adicionada ao [DbSet]; [SaveChangesAsync] então cria um [INSERT] e relê o identificador atribuído pelo banco de dados. Uma pessoa lida por este mesmo [DbContext] e modificada é detectada pelo rastreamento de alterações: [SaveChangesAsync] cria um [UPDATE] contendo apenas as colunas modificadas;
  • Linhas 34–35: [ExecuteDeleteAsync] envia um [DELETE] diretamente ao banco de dados, sem ler os registros antes.

A camada DAO não contém regras: apenas consultas. Esses métodos são assíncronos ([Task], [async] / [await]): enquanto o banco de dados processa, a thread é liberada e atende outras requisições.

9.1.6. A camada de negócio

O arquivo [Business/BusinessException.cs]:

1
2
3
4
namespace Example28.Business;

// uma regra de negócio rejeita a operação: a mensagem é destinada ao usuário
public class BusinessException(string message) : Exception(message);

Uma [BusinessException] indica que uma regra de negócio rejeitou uma operação. Não se trata de um erro de programa: a mensagem se destina ao usuário.

O arquivo [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);

// a camada de NEGÓCIO: as regras de negócio, e somente elas
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 () =>
        {
            // regra 1: não pode haver duas pessoas com os mesmos nome e sobrenome
            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);
            // regra 2: não modificamos um registro modificado nesse meio-tempo por outra pessoa
            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] é executado dentro de uma transação: COMMIT se tiver sucesso, ROLLBACK
    // se lançar uma exceção. Os erros do banco de dados viram 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)
        {
            // o UPDATE "WHERE id = ... AND version = ..." não modificou nenhuma linha
            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"))
        {
            // duas adições simultâneas: a restrição de unicidade do banco de dados rejeitou a segunda
            throw new BusinessException(Namesake);
        }
        // qualquer outra exceção segue seu caminho; a transação, fechada
        // sem COMMIT pelo "await using", é cancelada (ROLLBACK)
    }
}

Vamos detalhar este código:

  • linha 9: os dados de uma pessoa, como transmitidos pela camada web;
  • linha 12: a camada de negócio usa o DAO e o [DbContext] para abrir transações. Ambos são serviços [Scoped]: durante uma requisição, o DAO e a camada de negócio recebem o mesmo [DbContext], e portanto a mesma conexão e a mesma transação. (Com o [TypeORM], o objeto de transação precisava ser passado a cada método do DAO);
  • linhas 18–19: uma pessoa ausente é uma [BusinessException]. O operador [??] fornece um valor de substituição; [throw] pode servir como substituto;
  • linhas 21–30: a adição, dentro de uma transação. Regra: duas pessoas não podem ter o mesmo nome e sobrenome. Isso é verificado antes da gravação para exibir uma mensagem clara;
  • linhas 33–49: a atualização. Regra adicional: o bloqueio otimista (linhas 38–40). O formulário de atualização recuperou a versão do registro como estava quando o formulário foi aberto. Se ela mudou nesse meio-tempo (outro usuário modificou o mesmo registro), a atualização é rejeitada em vez de sobrescrever silenciosamente o trabalho do outro usuário;
  • linhas 61–67: [BeginTransactionAsync] abre uma transação ([START TRANSACTION]) e [CommitAsync] a confirma ([COMMIT]). [await using] fecha a transação ao sair do bloco, aconteça o que acontecer: se ela for fechada sem [COMMIT], é revertida ([ROLLBACK]). Assim, uma exceção lançada por [work] (inclusive uma [BusinessException]) reverte tudo o que foi feito;
  • linhas 70–73: a verificação de versão mencionada anteriormente nem sempre é suficiente: dois usuários podem salvar o mesmo registro ao mesmo tempo, e ambos passam na verificação. O [UPDATE ... WHERE id = ... AND version = ...] do segundo usuário então não modifica nenhuma linha; o EF Core detecta isso e lança uma [DbUpdateConcurrencyException], que se torna a mesma [BusinessException];
  • Linhas 75–79: da mesma forma, duas adições simultâneas da mesma pessoa passam na verificação de homônimos, mas a restrição de unicidade do banco de dados não permite que ambas sejam adicionadas. O erro do [MySQL] (código [DuplicateKeyEntry], nº 1062) ocorre aninhado dentro de uma [DbUpdateException] (propriedade [InnerException]); sua mensagem inclui o nome da restrição. A cláusula [when] intercepta a exceção somente se a condição for verdadeira. [is MySqlException { ErrorCode: ... } sqlError] é um filtro de padrão (pattern): ele testa o tipo e o valor de uma propriedade e armazena o objeto em uma variável.

9.1.7. A camada web

O arquivo [Models/PersonForm.cs]:

using System.ComponentModel.DataAnnotations;

namespace Example28.Models;

// os campos do formulário e suas restrições (veja o exemplo 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; }

    // a versão do registro, carregada por um campo oculto (somente na edição)
    public int? Version { get; set; }
}

// o modelo da view do formulário
public class FormView
{
    public required string Title { get; init; }  // "Add a person"...
    public required string Action { get; init; } // o endereço para onde o formulário é enviado
    public PersonForm Values { get; init; } = new();
    public Dictionary<string, string> Errors { get; init; } = new(StringComparer.OrdinalIgnoreCase);
}

// o modelo da partial view _Field
public record FieldModel(string Name, string Label, string Type, string? Value, string? Error);

O formulário e suas restrições (veja o Exemplo 19), incluindo a versão do registro (linha 24); o template da view do formulário, usado para adicionar e modificar registros (título e endereço de envio diferentes, [Action]); o template da view parcial [_Field] (veja o Exemplo 19).

O arquivo [Controllers/PersonsController.cs]:

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

namespace Example28.Controllers;

// a camada WEB: ela só conhece a camada de negócio
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)
        {
            // uma regra de negócio recusa: exibimos o formulário novamente, com a mensagem no pé da página
            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)
        {
            // nenhum formulário a exibir novamente: o erro também viaja em TempData
            TempData["Error"] = e.Message;
        }
        return RedirectToAction(nameof(List));
    }

    // o modelo da view do formulário, com os erros do ModelState ordenados por campo
    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);
    }
}

Vamos comentar este código:

  • linha 8: o controller conhece apenas a camada de negócio;
  • linha 11: a raiz do site redireciona para a lista;
  • linhas 14–16: uma ação assíncrona: ela retorna uma [Task<IActionResult>] e aguarda ([await]) a leitura da lista no banco de dados;
  • linhas 23–39: a adição, em três etapas: validação do formulário (erros: recarregamento da página), chamada à camada de negócio (sucesso: mensagem em [TempData] e redirecionamento, veja o Exemplo 20), [BusinessException] (nova exibição com a mensagem na parte inferior da página). Outra exceção não é capturada: trata-se de uma anomalia que resultará em um erro 500;
  • linhas 44–55: o formulário de atualização, preenchido com o registro recuperado do banco de dados, incluindo sua versão;
  • linhas 60–76: mesmo processo da adição; a versão retornada pelo formulário é passada à camada de negócio;
  • linhas 81–93: exclusão. Não há formulário a exibir novamente: eventuais erros também são transmitidos por meio de [TempData];
  • linhas 97–104: o template da view do formulário, com os erros de [ModelState] ordenados por campo (veja o Exemplo 19).

O arquivo [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>
  @* a versão do registro lido: ela voltará junto com o formulário *@
  <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>
  • linha 8: o campo oculto que transporta a versão do registro. A view é usada para adicionar e modificar registros: seu título e a URL de envio ([action]) são fornecidos pelo controller.

O arquivo [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">
    @* a mensagem de sucesso (TempData, após um redirecionamento): no topo *@
    @if (TempData["Success"] is string success)
    {
      <div class="alert alert-success" role="status">@success</div>
    }
    @RenderBody()
    @* o erro: da requisição atual (ViewData) ou de antes do redirecionamento (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>
  • linha 12: a mensagem de sucesso, na parte superior da página;
  • linha 18: a mensagem de erro, na parte inferior da página: seja a da requisição atual ([ViewData]), seja a exibida antes de um redirecionamento ([TempData]).

As views [List.cshtml] e [_Field.cshtml] e o script de confirmação são os mesmos dos Exemplos 19 e 21.

9.1.8. Execução

Se os valores em [appsettings.json] não forem adequados (uma senha para [root], por exemplo), eles podem ser substituídos, sem modificar o arquivo, por variáveis de ambiente: o separador de seções [:] é escrito como [__] (dois sublinhados). No [Windows] ([PowerShell]):

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

A lista, a partir da URL http://localhost:5000/:

Image

Um formulário inválido:

Image

Um homônimo: a regra de negócio o detecta. O [MySQL], que compara com base na collation do banco de dados, também rejeitaria [marie pelissier], escrito em minúsculas e sem acentos:

Image

Uma adição bem-sucedida:

Image

Com o nível de log [Information] definido para [Microsoft.EntityFrameworkCore.Database.Command], o console passa a exibir, para cada requisição SQL, o texto da requisição, seus parâmetros (ocultos por padrão, por precaução) e seu tempo de execução: vemos a transação, a busca de homônimos ([SELECT ... LIMIT 1]), o [INSERT] seguido da leitura do identificador atribuído, o [COMMIT] e, em seguida, após o redirecionamento, a leitura da lista ([SELECT ... ORDER BY]).

O bloqueio otimista: dois formulários estão abertos para o mesmo registro; o primeiro é salvo (a versão passa para 2); o segundo, que ainda tem a versão 1, é rejeitado:

Image

Exclusão, com confirmação:

Image

Image