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]:
| 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/:

Um formulário inválido:

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:

Uma adição bem-sucedida:

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:

Exclusão, com confirmação:

