9. Arquitectura en capas y acceso a datos
Los ejemplos anteriores mantenían sus datos en memoria. Una aplicación real los almacena en una base de datos y se organiza en capas (vea el diagrama de la introducción):
- la capa web (controladores, vistas): lee la solicitud, llama a la capa de negocio y selecciona la vista;
- la capa de negocio: reglas de negocio;
- la capa DAO ([Data Access Object]): consultas a la base de datos.
Cada capa conoce únicamente la capa inferior y, de ella, los mínimos detalles posibles: la capa web ignora SQL y la capa de negocio ignora HTML. Esta separación facilita comprender, probar y evolucionar cada capa. El ejemplo 28 aplica esto a la gestión de una lista de personas: es, en pequeña escala, la gestión de médicos y clientes del caso de estudio.
El acceso a la base de datos está a cargo de Entity Framework Core (EF Core), el ORM ([Object-Relational Mapper]) de [.NET]: asigna las clases de [C#] (las entidades) a las tablas de la base de datos, traduce a SQL las consultas escritas en [LINQ] y transforma las filas recuperadas en objetos. EF Core se comunica con cada tipo de base de datos mediante un proveedor ([provider]): para [MySQL], el paquete [NuGet] que incluye [Pomelo.EntityFrameworkCore.MySql], que a su vez incluye EF Core y el controlador [MySqlConnector].
9.1. Ejemplo 28: un sistema de gestión de personal de tres capas
| 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. La base de datos
La base de datos [dbpersons] se crea mediante un script SQL. Con [Laragon], puede ejecutarlo, por ejemplo, en la herramienta [HeidiSQL] (menú Archivo / Ejecutar archivo SQL), o desde la línea de comandos:
| mysql -u root < database/dbpersons.sql
|
El archivo [database/dbpersons.sql]:
| -- base de datos del ejemplo 28: una sola tabla, [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),
-- dos personas no pueden tener los mismos nombres y apellidos
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);
|
- línea 3: el conjunto de caracteres [utf8mb4] acepta todos los caracteres (acentos, emojis, etc.). La intercalación [utf8mb4_unicode_ci] compara las cadenas sin distinguir mayúsculas ni acentos: para [MySQL], [pelissier] y [Pélissier] son iguales;
- línea 8: un número de versión, que se incrementa cada vez que se modifica la fila (vea “bloqueo optimista”, más adelante);
- línea 14: una restricción de unicidad con nombre: la base de datos no permite dos personas con el mismo nombre y apellido. El nombre servirá para identificar el error.
9.1.2. La configuración
El archivo [Example28.csproj]:
| <Project Sdk="Microsoft.NET.Sdk.Web">
<ItemGroup>
<!-- Entity Framework Core y su proveedor MySQL / MariaDB -->
<PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
</ItemGroup>
<ItemGroup>
<!-- el script SQL no es un archivo de la aplicación -->
<Content Remove="database\**" />
<None Include="database\**" />
</ItemGroup>
</Project>
|
- línea 5: el proveedor [MySQL] para EF Core;
- líneas 10–11: el script SQL no es un archivo de la aplicación: se excluye de los archivos publicados.
El archivo [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"
}
}
|
- línea 6: EF Core registra cada comando SQL enviado a la base de datos en el nivel [Information]. El nivel [Warning] los oculta; basta reemplazarlo por [Information] para verlos en la consola;
- líneas 10–11: la cadena de conexión: servidor, puerto, base de datos, nombre de usuario, contraseña. Son los valores predeterminados de [Laragon] (usuario [root], sin contraseña);
- línea 14: la versión del servidor [MySQL]. El proveedor [Pomelo] adapta el SQL que genera a esta versión. Por ejemplo, una versión de [MariaDB] se escribiría [10.11.0-mariadb].
El archivo [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);
// la conexión a la base de datos: cadena de conexión y versión del servidor, leídas de appsettings.json
var connectionString = builder.Configuration.GetConnectionString("DbPersons")!;
var version = ServerVersion.Parse(builder.Configuration["MySql:ServerVersion"]!);
// AddDbContext: un DbContext por solicitud (tiempo de vida Scoped)
builder.Services.AddDbContext<PersonsDbContext>(options => options.UseMySql(connectionString, version));
// las capas DAO y de negocio: Scoped, como el DbContext que usan
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();
|
- línea 12: [GetConnectionString("DbPersons")] lee la propiedad [DbPersons] de la sección [ConnectionStrings];
- línea 15: [AddDbContext] registra [DbContext] (vea más adelante), con un tiempo de vida [Scoped]: uno por solicitud. [UseMySql] selecciona el proveedor [MySQL];
- líneas 18–19: las capas DAO y de negocio, que también tienen un tiempo de vida [Scoped]: usan [DbContext], que no puede durar más que una sola solicitud (vea el capítulo 6);
- línea 22: un mensaje de error de conversión (vea el ejemplo 19).
9.1.3. La entidad Person
El archivo [Entities/Person.cs]:
| using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace Example28.Entities;
// una fila de la tabla [persons]
[Table("persons")]
public class Person
{
// la clave primaria: una clave entera es, por convención, generada por la base de datos
// (AUTO_INCREMENT); EF Core lee su valor de vuelta después de cada INSERT
[Key]
[Column("id")]
public int Id { get; set; }
// el bloqueo optimista: cada UPDATE lleva la condición "AND version = <valor leído>"
[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; }
}
|
- línea 7: la clase [Person] corresponde a la tabla [persons]: cada fila de la tabla será un objeto [Person];
- líneas 12–14: la clave primaria ([[Key]]). [[Column]] especifica el nombre de la columna correspondiente a cada propiedad;
- líneas 18–19: la columna de versión. [[ConcurrencyCheck]] indica a EF Core que agregue la condición [AND version = <value read>] a cada [UPDATE]: es el bloqueo optimista, que se explica más adelante;
- línea 22: las demás columnas. [[MaxLength]] especifica el tamaño de la columna.
9.1.4. El DbContext
El archivo [Data/PersonsDbContext.cs]:
| using Example28.Entities;
using Microsoft.EntityFrameworkCore;
namespace Example28.Data;
// el DbContext: la conexión a la base de datos y el seguimiento de las entidades leídas
public class PersonsDbContext(DbContextOptions<PersonsDbContext> options) : DbContext(options)
{
// la "tabla" de personas: se consulta con LINQ
public DbSet<Person> Persons => Set<Person>();
// justo antes de cada guardado: la versión de cada persona MODIFICADA
// aumenta en 1. El UPDATE generado compara el valor ANTERIOR:
// 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);
}
}
|
- línea 7: DbContext es el objeto central de EF Core. Representa una sesión de trabajo con la base de datos: abre conexiones, envía consultas y hace seguimiento de las entidades que ha leído (sabe cuáles han sido modificadas);
- línea 10: un [DbSet<Person>] representa la tabla: se consulta mediante [LINQ] y se le agregan entidades;
- líneas 15–24: [SaveChangesAsync] envía a la base de datos todos los cambios pendientes. Se redefine para incrementar el número de versión de cada persona modificada. [ChangeTracker] hace seguimiento de los cambios: para cada entidad rastreada, conoce su estado ([Added], [Modified], [Deleted], [Unchanged]). A diferencia de [TypeORM], EF Core no administra por sí solo una columna de versión entera: nos corresponde a nosotros incrementarla.
9.1.5. La capa DAO
El archivo [Dao/PersonsDao.cs]:
| using Example28.Data;
using Example28.Entities;
using Microsoft.EntityFrameworkCore;
namespace Example28.Dao;
// la capa DAO: consultas, sin reglas de negocio
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 si no existe
public Task<Person?> ReadAsync(int id) =>
db.Persons.FirstOrDefaultAsync(p => p.Id == id);
// una persona con los mismos nombre y apellido, distinta 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 si la persona es nueva (Id = 0), UPDATE de las columnas modificadas en caso contrario
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, sin leer antes a la persona
public Task DeleteAsync(int id) =>
db.Persons.Where(p => p.Id == id).ExecuteDeleteAsync();
}
|
- línea 8: el DAO recibe [DbContext] mediante inyección;
- líneas 11–12: una consulta [LINQ], traducida a SQL por EF Core. No se envía nada a la base de datos antes de la llamada a [ToListAsync], que ejecuta la consulta y devuelve la lista. [AsNoTracking()] indica que estas entidades no se modificarán: [DbContext] no necesita hacerles seguimiento;
- líneas 15–16: la primera entidad que cumple la condición, o [null];
- líneas 19–20: una persona con el mismo nombre y apellido, distinta de [exceptId]: útil para modificar un registro, que no debe entrar en conflicto consigo mismo. La comparación la realiza [MySQL], es decir, según la intercalación de la base de datos: sin distinguir mayúsculas ni acentos;
- líneas 23–30: una nueva persona ([Id] igual a 0) se agrega a [DbSet]; [SaveChangesAsync] crea entonces un [INSERT] y vuelve a leer el identificador asignado por la base de datos. Una persona leída por este mismo [DbContext] y modificada es detectada por el seguimiento de cambios: [SaveChangesAsync] crea un [UPDATE] que contiene solo las columnas modificadas;
- líneas 34–35: [ExecuteDeleteAsync] envía un [DELETE] directamente a la base de datos, sin leer antes los registros.
La capa DAO no contiene reglas: solo consultas. Estos métodos son asíncronos ([Task], [async] / [await]): mientras la base de datos procesa, el hilo queda libre y atiende otras solicitudes.
9.1.6. La capa de negocio
El archivo [Business/BusinessException.cs]:
| namespace Example28.Business;
// una regla de negocio rechaza la operación: el mensaje está destinado al usuario
public class BusinessException(string message) : Exception(message);
|
Una [BusinessException] indica que una regla de negocio ha rechazado una operación. No es un error del programa: el mensaje está destinado al usuario.
El archivo [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);
// la capa de NEGOCIO: las reglas de negocio, y solo ellas
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 () =>
{
// regla 1: no puede haber dos personas con el mismo nombre y apellido
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);
// regla 2: no modificamos un registro modificado mientras tanto por otra persona
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] se ejecuta dentro de una transacción: COMMIT si tiene éxito, ROLLBACK
// si lanza una excepción. Los errores de la base de datos se convierten en 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)
{
// el UPDATE "WHERE id = ... AND version = ..." no modificó ninguna fila
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"))
{
// dos altas simultáneas: la restricción de unicidad de la base de datos rechazó la segunda
throw new BusinessException(Namesake);
}
// cualquier otra excepción sigue su camino; la transacción, cerrada
// sin COMMIT por "await using", se cancela (ROLLBACK)
}
}
|
Analicemos este código:
- línea 9: los datos de una persona, tal como los transmite la capa web;
- línea 12: la capa de negocio usa el DAO y [DbContext] para abrir transacciones. Ambos son servicios [Scoped]: durante una solicitud, el DAO y la capa de negocio reciben el mismo [DbContext] y, por lo tanto, la misma conexión y la misma transacción. (Con [TypeORM], había que pasar el objeto de transacción a cada método del DAO);
- líneas 18–19: una persona ausente es una [BusinessException]. El operador [??] proporciona un valor de reemplazo; [throw] puede servir como sustituto;
- líneas 21–30: la adición, dentro de una transacción. Regla: no puede haber dos personas con el mismo nombre y apellido. Esto se verifica antes de la escritura para mostrar un mensaje claro;
- líneas 33–49: la actualización. Regla adicional: el bloqueo optimista (líneas 38–40). El formulario de actualización recuperó la versión del registro tal como estaba cuando se abrió el formulario. Si ha cambiado entretanto (otro usuario modificó el mismo registro), la actualización se rechaza en lugar de sobrescribir silenciosamente el trabajo del otro usuario;
- líneas 61–67: [BeginTransactionAsync] abre una transacción ([START TRANSACTION]) y [CommitAsync] la confirma ([COMMIT]). [await using] cierra la transacción al salir del bloque, suceda lo que suceda: si se cierra sin [COMMIT], se revierte ([ROLLBACK]). Así, una excepción lanzada por [work] (incluida una [BusinessException]) revierte todo lo que se haya hecho;
- líneas 70–73: la verificación de versión mencionada antes no siempre es suficiente: dos usuarios pueden guardar el mismo registro al mismo tiempo y ambos pasan la verificación. El [UPDATE ... WHERE id = ... AND version = ...] del segundo usuario no modifica entonces ninguna fila; EF Core lo detecta y lanza una [DbUpdateConcurrencyException], que se convierte en la misma [BusinessException];
- líneas 75–79: del mismo modo, dos adiciones simultáneas de la misma persona pasan la verificación de homónimos, pero la restricción de unicidad de la base de datos no permite agregarlas. El error de [MySQL] (código [DuplicateKeyEntry], n.º 1062) aparece anidado dentro de una [DbUpdateException] (propiedad [InnerException]); su mensaje incluye el nombre de la restricción. La cláusula [when] intercepta la excepción solo si la condición es verdadera. [is MySqlException { ErrorCode: ... } sqlError] es un filtro de patrón: comprueba el tipo y el valor de una propiedad y almacena el objeto en una variable.
9.1.7. La capa web
El archivo [Models/PersonForm.cs]:
| using System.ComponentModel.DataAnnotations;
namespace Example28.Models;
// los campos del formulario y sus restricciones (ver ejemplo 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; }
// la versión del registro, llevada por un campo oculto (solo en edición)
public int? Version { get; set; }
}
// el modelo de la vista del formulario
public class FormView
{
public required string Title { get; init; } // "Add a person"...
public required string Action { get; init; } // la dirección a la que se envía el formulario
public PersonForm Values { get; init; } = new();
public Dictionary<string, string> Errors { get; init; } = new(StringComparer.OrdinalIgnoreCase);
}
// el modelo de la vista parcial _Field
public record FieldModel(string Name, string Label, string Type, string? Value, string? Error);
|
El formulario y sus restricciones (vea el ejemplo 19), incluida la versión del registro (línea 24); la plantilla de vista del formulario, utilizada para agregar y modificar registros (título y dirección de envío distintos, [Action]); la plantilla de vista parcial [_Field] (vea el ejemplo 19).
El archivo [Controllers/PersonsController.cs]:
| using Example28.Business;
using Example28.Models;
using Microsoft.AspNetCore.Mvc;
namespace Example28.Controllers;
// la capa WEB: solo conoce la capa de negocio
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)
{
// una regla de negocio lo rechaza: mostramos el formulario de nuevo, con el mensaje al pie de la 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)
{
// no hay formulario que mostrar de nuevo: el error también viaja en TempData
TempData["Error"] = e.Message;
}
return RedirectToAction(nameof(List));
}
// el modelo de la vista del formulario, con los errores de 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);
}
}
|
Comentemos este código:
- línea 8: el controlador solo conoce la capa de negocio;
- línea 11: la raíz del sitio redirige a la lista;
- líneas 14–16: una acción asíncrona: devuelve una [Task<IActionResult>] y espera ([await]) a que se lea la lista de la base de datos;
- líneas 23–39: la adición, en tres pasos: validación del formulario (errores: se vuelve a cargar la página), llamada a la capa de negocio (éxito: mensaje en [TempData] y redirección, vea el ejemplo 20) y [BusinessException] (se vuelve a mostrar con el mensaje al pie de la página). Cualquier otra excepción no se captura: es una anomalía que dará como resultado un error 500;
- líneas 44–55: el formulario de actualización, rellenado con el registro recuperado de la base de datos, incluida su versión;
- líneas 60–76: mismo proceso que para la adición; la versión devuelta por el formulario se pasa a la capa de negocio;
- líneas 81–93: la eliminación. No hay formulario que volver a mostrar: los errores también se transmiten mediante [TempData];
- líneas 97–104: la plantilla de vista del formulario, con los errores de [ModelState] ordenados por campo (vea el ejemplo 19).
El archivo [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>
@* la versión del registro leído: volverá junto con el formulario *@
<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>
|
- línea 8: el campo oculto que transporta la versión del registro. La vista se usa para agregar y modificar registros: su título y la URL de envío ([action]) los proporciona el controlador.
El archivo [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">
@* el mensaje de éxito (TempData, tras una redirección): en la parte superior *@
@if (TempData["Success"] is string success)
{
<div class="alert alert-success" role="status">@success</div>
}
@RenderBody()
@* el error: de la solicitud actual (ViewData) o de antes de la redirección (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>
|
- línea 12: el mensaje de éxito, en la parte superior de la página;
- línea 18: el mensaje de error, al pie de la página: ya sea el de la solicitud actual ([ViewData]) o el que se mostró antes de una redirección ([TempData]).
Las vistas [List.cshtml] y [_Field.cshtml] y el script de confirmación son los mismos que los de los ejemplos 19 y 21.
9.1.8. Ejecución
Si los valores de [appsettings.json] no son adecuados (una contraseña para [root], por ejemplo), pueden reemplazarse —sin modificar el archivo— con variables de entorno: el separador de secciones [:] se escribe [__] (dos guiones bajos). En [Windows] ([PowerShell]):
| $env:ConnectionStrings__DbPersons="server=localhost;database=dbpersons;user=root;password=secret"; dotnet run
|
La lista, a partir de la URL http://localhost:5000/:

Un formulario no válido:

Un homónimo: la regla de negocio lo detecta. [MySQL], que compara según la intercalación de la base de datos, también rechazaría [marie pelissier], escrito en minúsculas y sin acentos:

Una adición exitosa:

Con el nivel de registro [Information] establecido para [Microsoft.EntityFrameworkCore.Database.Command], la consola muestra entonces, para cada consulta SQL, el texto de la consulta, sus parámetros (ocultos de forma predeterminada, por precaución) y su tiempo de ejecución: se ven la transacción, la búsqueda de homónimos ([SELECT ... LIMIT 1]), el [INSERT] seguido de la lectura del identificador asignado, el [COMMIT] y luego, tras la redirección, la lectura de la lista ([SELECT ... ORDER BY]).
El bloqueo optimista: dos formularios están abiertos sobre el mismo registro; se guarda el primero (la versión sube a 2); el segundo, que todavía tiene la versión 1, es rechazado:

Eliminación, con confirmación:

