Skip to content

4. La vista y su modelo

Hasta ahora, las acciones han generado sus propias respuestas. En una aplicación MVC, este es el papel de una vista: un archivo que describe la página HTML, con marcadores de posición para los datos que le pasa la acción —el modelo de la vista. [ASP.NET Core MVC] usa el motor de vistas [Razor]: una vista es un archivo [.cshtml], derivado de HTML, en el que se inserta código [C#] precedido por el carácter [@]. [Razor] forma parte del framework: no hay nada que instalar.

4.1. Ejemplo 13: Una primera vista

El archivo [Program.cs]:

1
2
3
4
5
6
7
8
var builder = WebApplication.CreateBuilder(args);

// los servicios de MVC: controladores Y vistas Razor
builder.Services.AddControllersWithViews();

var app = builder.Build();
app.MapControllers();
app.Run();
  • Línea 4: [AddControllersWithViews] reemplaza a [AddControllers] de los ejemplos anteriores. Agrega a los servicios de controladores los servicios de vistas: el motor [Razor], la búsqueda de archivos de vista y los Tag Helpers (ejemplo 15).

El modelo de la vista es una clase simple. El archivo [Models/PageModel.cs]:

1
2
3
4
namespace Example13.Models;

// el modelo de vista: los datos que la acción pasa a la vista
public record PageModel(string Title, string Message, string Time);
  • línea 4: un [record] es una clase cuyas propiedades se establecen mediante el constructor; aquí, tres cadenas: [Title], [Message] y [Time]. Es una forma concisa de definir una clase que simplemente transporta datos.

El archivo [Controllers/ViewsController.cs]:

using Example13.Models;
using Microsoft.AspNetCore.Mvc;

namespace Example13.Controllers;

public class ViewsController : Controller
{
    // View(model): la vista que lleva el nombre de la acción (Views/Views/Index.cshtml)
    [HttpGet("/")]
    public IActionResult Index()
    {
        var model = new PageModel(
            "My first view",
            "This page was built by Razor, on the server.",
            DateTime.Now.ToString("HH:mm:ss"));
        return View(model);
    }

    // View(name, model): la vista la elige la acción
    [HttpGet("hello/{name}")]
    public IActionResult Hello(string name)
    {
        if (name == "unknown")
        {
            Response.StatusCode = 404;
            return View("Unknown", name);
        }
        var model = new PageModel(
            $"Hello {name}",
            "This time, the action designated the view by its name.",
            DateTime.Now.ToString("HH:mm:ss"));
        return View("Index", model);
    }
}

Comentemos este código:

  • línea 6: el controlador deriva de la clase [Controller], en lugar de [ControllerBase]: [Controller] agrega a [ControllerBase] todo lo relacionado con las vistas (los métodos [View], [ViewData], [TempData], etc.);
  • líneas 12–15: la acción genera el modelo de la vista: un título, un mensaje y la hora actual;
  • línea 16: [View(model)] devuelve un [ViewResult]: la acción ya no genera la respuesta; en su lugar, designa una vista y le pasa un modelo. Si no se especifica ningún nombre de vista, se usa la vista con el mismo nombre que la acción: [Index];
  • líneas 23–26: cuando la vista depende de la solicitud, la acción elige la vista. Aquí, el nombre [unknown] muestra la vista [Unknown], con código de estado 404. El modelo de esta vista es una simple cadena;
  • línea 32: la acción [Hello] especifica explícitamente la vista [Index] por su nombre: dos acciones comparten la misma vista, con modelos diferentes.

¿Dónde busca [ASP.NET Core] la vista [Index] de la acción [ViewsController.Index]? Por convención, en dos carpetas, en este orden:

  • [Views/Views/Index.cshtml]: la carpeta que lleva el nombre del controlador (sin el sufijo [Controller]);
  • [Views/Shared/Index.cshtml]: la carpeta que contiene las vistas compartidas por todos los controladores (véase el ejemplo 15).

Si la vista no se encuentra en ningún lugar, una excepción enumera las rutas que se comprobaron. Los archivos del proyecto:

13-first-view/
├── Controllers/
│   └── ViewsController.cs
├── Models/
│   └── PageModel.cs
├── Views/
│   ├── Views/
│   │   ├── Index.cshtml
│   │   └── Unknown.cshtml
│   └── _ViewImports.cshtml
├── appsettings.json
├── Example13.csproj
└── Program.cs

El archivo [Views/_ViewImports.cshtml]:

@* las directivas "using" compartidas por todas las vistas de la carpeta Views *@
@using Example13.Models
  • Línea 1: [@* ... *@] es un comentario [Razor]: no aparece en la página generada (a diferencia de un comentario HTML [<!-- -->]);
  • Línea 2: las directivas del archivo [_ViewImports.cshtml] se aplican a todas las vistas de su carpeta y subcarpetas. [@using Example13.Models] permite escribir [PageModel] en lugar de [Example13.Models.PageModel] en las vistas.

El archivo [Views/Views/Index.cshtml]:

@* el tipo del modelo de esta vista *@
@model PageModel
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>@Model.Title</title>
</head>
<body>
  <h1>@Model.Title</h1>
  <p>@Model.Message</p>
  <p>Page built at @Model.Time.</p>
</body>
</html>
  • línea 2: la directiva [@model] declara el tipo del modelo de la vista. En la vista, la propiedad [Model] es entonces de tipo [PageModel], y el compilador verifica que [Model.Title] exista;
  • Líneas 7–12: cada expresión [@Model.Title] se reemplaza por el valor correspondiente del modelo. [Razor] reconoce por sí mismo el final de una expresión: en [@Model.Time.], el punto va seguido de una etiqueta, por lo que no es un acceso a una propiedad.

Una vista es un archivo [C#] disfrazado: cuando se compila el proyecto ([dotnet build]), cada archivo [.cshtml] se traduce a una clase [C#], que se compila junto con el resto de la aplicación. Por lo tanto, un error en una vista ([@Model.Titl]) se informa durante la compilación. El resultado, en la URL http://localhost:5000/:

Image

El código fuente de la página recibida por el navegador ya no contiene ningún rastro de [Razor]:

curl http://localhost:5000/
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>My first view</title>
</head>
<body>
  <h1>My first view</h1>
  <p>This page was built by Razor, on the server.</p>
  <p>Page built at 12:12:36.</p>
</body>
</html>

Observe que los caracteres acentuados insertados mediante una expresión [@] se codificarían (esta página no contiene ninguno): un título en francés como [Ma première vue] se enviaría como [Ma premi&#xE8;re vue], donde [&#xE8;] es el código del carácter [è], mientras que el texto acentuado escrito directamente en la vista permanecería sin cambios. El navegador muestra ambos correctamente, pero el código HTML resulta difícil de leer. Veremos en el ejemplo 15 cómo evitarlo. La URL http://localhost:5000/hello/martin muestra la misma vista con un modelo diferente:

Image

y http://localhost:5000/hello/unknown muestra una vista distinta:

curl -i http://localhost:5000/hello/unknown
HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Unknown</title>
</head>
<body>
  <h1>Nobody is called [unknown] here.</h1>
</body>
</html>

El archivo [Views/Views/Unknown.cshtml]:

@* el modelo de esta vista es una simple cadena: el nombre solicitado *@
@model string
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Unknown</title>
</head>
<body>
  <h1>Nobody is called [@Model] here.</h1>
</body>
</html>
  • Línea 2: el modelo de esta vista es una cadena;
  • línea 10: [@Model] es la propia cadena.

4.2. Ejemplo 14: El lenguaje Razor

[Razor] no es un lenguaje de plantillas “sin lógica” como [Handlebars]: se puede escribir código [C#] dentro de una vista (condiciones, bucles, variables, llamadas a métodos). Esta libertad exige disciplina: la vista debe seguir siendo puramente de presentación; los cálculos y las decisiones corresponden a la acción y a los servicios. El ejemplo 14 ofrece una visión general de la sintaxis. El modelo, archivo [Models/BasicsModel.cs]:

namespace Example14.Models;

public record Product(string Name, decimal Price, bool InStock);

public record Address(string Street, string City);

public class BasicsModel
{
    public string Title { get; set; } = "";
    public string Name { get; set; } = "";
    public string? Nickname { get; set; }
    public string Html { get; set; } = "";
    public bool LoggedIn { get; set; }
    public string Currency { get; set; } = "";
    public List<Product> Products { get; set; } = [];
    public List<Product> Cart { get; set; } = [];
    public Address Address { get; set; } = new("", "");
}

El archivo [Controllers/BasicsController.cs]:

using Example14.Models;
using Microsoft.AspNetCore.Mvc;

namespace Example14.Controllers;

public class BasicsController : Controller
{
    [HttpGet("/")]
    public IActionResult Index()
    {
        var model = new BasicsModel
        {
            Title = "Razor basics",
            Name = "Martin",
            Nickname = null,
            Html = "<b>this is HTML</b>",
            LoggedIn = true,
            Currency = "€",
            Products =
            [
                new Product("Keyboard", 25m, true),
                new Product("Mouse", 12.5m, false),
                new Product("Screen", 149m, true),
            ],
            Cart = [],
            Address = new Address("12 rue des Lilas", "Angers"),
        };
        return View(model);
    }
}
  • líneas 11–26: la acción rellena el modelo: algunas cadenas, un valor booleano, una lista de tres productos, un carrito de compras vacío y una dirección. [Nickname] es intencionalmente igual a [null].

La vista, archivo [Views/Basics/Index.cshtml]:

@model BasicsModel
@* un bloque de código C#: no produce nada en la página *@
@{
    var total = Model.Products.Sum(p => p.Price);
    var count = Model.Products.Count;
}
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>@Model.Title</title>
</head>
<body>
  <h1>@Model.Title</h1>
  @* 1. mostrar un valor del modelo; un valor null no muestra nada *@
  <p>1. Name: @Model.Name - nickname: [@Model.Nickname]</p>
  @* 2. @ escapa el HTML, @Html.Raw lo inserta tal cual *@
  <p>2a. @Model.Html</p>
  <p>2b. @Html.Raw(Model.Html)</p>
  @* 3. una condición *@
  @if (Model.LoggedIn)
  {
    <p>3. You are logged in.</p>
  }
  else
  {
    <p>3. You are not logged in.</p>
  }
  @* 4. un bucle; las variables del bucle son variables de C# *@
  <p>4. Our products:</p>
  <ul>
    @for (var i = 0; i < Model.Products.Count; i++)
    {
      var product = Model.Products[i];
      <li>no. @i: @product.Name, @product.Price @Model.Currency
        @(product.InStock ? "(in stock)" : "(sold out)")
        @if (i == 0) { <text>- the first one</text> }
        @if (i == Model.Products.Count - 1) { @:- the last one, seen by @Model.Name
        }
      </li>
    }
  </ul>
  @* 5. la lista vacía *@
  <p>5. Your cart:
    @if (Model.Cart.Count == 0)
    {
      <text>it is empty.</text>
    }
    else
    {
      foreach (var p in Model.Cart) { <span>@p.Name</span> }
    }
  </p>
  @* 6. una expresión explícita @( ... ), y las variables del bloque @{ } *@
  <p>6. @count products, for a total of @(total) @Model.Currency; average price: @((total / count).ToString("0.00")) @Model.Currency</p>
  <p>7. Address: @Model.Address.Street, @Model.Address.City.ToUpper()</p>
  <p>8. An email address: contact@example.com</p>
</body>
</html>

Comentemos este código:

  • líneas 2–5: un bloque de código [@{ ... }] contiene instrucciones [C#]. No produce nada en la página. Las variables que declara ([total], [count]) pueden usarse más adelante en la vista;
  • línea 16: un valor [null] ([@Model.Nickname]) no muestra nada, sin ningún error;
  • líneas 18–19: una expresión [@...] escapa los caracteres especiales de HTML ([<] se convierte en [&lt;]...): el texto se muestra tal cual. [@Html.Raw(...)] lo inserta sin escapar: se interpreta como HTML. [Html.Raw] solo se usa para HTML generado por la aplicación, nunca para datos introducidos por un usuario: este podría inyectar HTML, e incluso [JavaScript], en la página (un ataque conocido como [XSS], [cross-site scripting]);
  • líneas 21–27: una condición. Después de [@if (...)], el contenido entre llaves es HTML: [Razor] reconoce el inicio de una etiqueta y vuelve al modo HTML. Regresamos a [C#] mediante [@];
  • líneas 32–40: un bucle [for] de [C#]. [var product = ...] es una instrucción [C#], [<li>] es de HTML: [Razor] alterna entre ambos sin ningún marcador específico;
  • línea 36: una expresión explícita [@( ... )]. Los paréntesis son obligatorios siempre que la expresión contenga espacios u operadores (en este caso, el operador condicional [? :]);
  • línea 37: para escribir texto sin formato dentro de un bloque [C#], enciérrelo en la etiqueta especial [<text>], que no aparece en la página;
  • línea 38: [@:] hace lo mismo para el resto de la línea;
  • líneas 45–51: una lista vacía es simplemente un [if]. En el bloque [else], que ya está en modo [C#], [foreach] se escribe sin [@];
  • línea 55: las variables del bloque [@{ }] y las expresiones explícitas, incluida una llamada a un método: [ToString("0.00")] formatea un número con dos decimales;
  • línea 56: una ruta con puntos [@Model.Address.Street] y una llamada a un método [ToUpper()];
  • línea 57: [Razor] reconoce que una [@] colocada entre dos caracteres alfanuméricos no es código: [contact@example.com] es una dirección de correo electrónico. Para escribir una [@] que sería ambigua, se duplica: [@@].

El resultado, en la URL http://localhost:5000/:

Image

El código HTML producido:

curl http://localhost:5000/
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Razor basics</title>
</head>
<body>
  <h1>Razor basics</h1>
  <p>1. Name: Martin - nickname: []</p>
  <p>2a. &lt;b&gt;this is HTML&lt;/b&gt;</p>
  <p>2b. <b>this is HTML</b></p>
    <p>3. You are logged in.</p>
  <p>4. Our products:</p>
  <ul>
      <li>no. 0: Keyboard, 25 &#x20AC;
        (in stock)
- the first one      </li>
      <li>no. 1: Mouse, 12.5 &#x20AC;
        (sold out)
      </li>
      <li>no. 2: Screen, 149 &#x20AC;
        (in stock)
 - the last one, seen by Martin
      </li>
  </ul>
  <p>5. Your cart:
it is empty.  </p>
  <p>6. 3 products, for a total of 186.5 &#x20AC;; average price: 62.17 &#x20AC;</p>
  <p>7. Address: 12 rue des Lilas, ANGERS</p>
  <p>8. An email address: contact@example.com</p>
</body>
</html>

Observe los espacios y las líneas en blanco que dejan las instrucciones [C#]: no tienen efecto en la visualización. También vemos la codificación de los caracteres acentuados provenientes de expresiones ([&#x20AC;] para [€]), lo cual se corrige en el siguiente ejemplo.

4.3. Ejemplo 15: plantilla, vistas parciales, archivos estáticos

Las páginas de un sitio web comparten una plantilla común (encabezado, barra de navegación, pie de página). [Razor] llama a esta plantilla “layout”: cada vista se inserta en ella. Los componentes reutilizables de la página son las vistas parciales. Por último, las páginas necesitan archivos estáticos (hojas de estilo, imágenes, scripts), que se sirven tal cual, sin pasar por un controlador. Los archivos del ejemplo:

15-layout/
├── Controllers/
│   └── PagesController.cs
├── Views/
│   ├── Pages/
│   │   ├── Home.cshtml
│   │   ├── Raw.cshtml
│   │   └── Team.cshtml
│   ├── Shared/
│   │   ├── _Card.cshtml
│   │   ├── _Layout.cshtml
│   │   └── _Navbar.cshtml
│   ├── _ViewImports.cshtml
│   └── _ViewStart.cshtml
├── wwwroot/
│   └── css/
│       └── styles.css
├── appsettings.json
├── Example15.csproj
└── Program.cs

El archivo [Program.cs]:

using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
// Razor escribe los caracteres acentuados tal cual (y no "&#xE9;");
// < > & " ' siguen escapados
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));

var app = builder.Build();

// 1. los archivos estáticos de la carpeta wwwroot: wwwroot/css/styles.css se sirve como /css/styles.css
app.UseStaticFiles();
// 2. Bootstrap, compartido por los ejemplos: la carpeta examples/common/bootstrap se sirve bajo /bootstrap
app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
    RequestPath = "/bootstrap",
});

app.MapControllers();
app.Run();

Comentemos este código:

  • línea 9: el servicio [HtmlEncoder] es el que utiliza [Razor] para escapar las expresiones en [@]. De forma predeterminada, solo deja pasar los caracteres del alfabeto latino básico: por eso [é] se codifica como [&#xE9;] (y [€] como [&#x20AC;]). Reemplazamos este servicio por un codificador que deja pasar todos los caracteres ([UnicodeRanges.All]). Los caracteres peligrosos ([<], [>], [&], ["], [']) siguen escapados: la protección contra la inyección de HTML permanece intacta. Todos los ejemplos siguientes, así como el caso de estudio, incluyen esta línea;
  • línea 14: un componente de middleware (véase el capítulo 7) que sirve los archivos de la carpeta [wwwroot] del proyecto: el archivo [wwwroot/css/styles.css] se sirve en la URL [/css/styles.css]. Si el archivo no existe, la solicitud continúa hacia los controladores;
  • líneas 16–19: un segundo servicio de archivos estáticos. El framework CSS [Bootstrap] es común a todos los ejemplos: se almacena una sola vez, en la carpeta [examples/common/bootstrap], y se sirve bajo el prefijo [/bootstrap]. [PhysicalFileProvider] designa una carpeta del disco; [ContentRootPath] es la carpeta del proyecto. Así, [examples/common/bootstrap/css/bootstrap.min.css] se sirve en la URL [/bootstrap/css/bootstrap.min.css]. El caso de estudio, en cambio, coloca [Bootstrap] en su propia carpeta [wwwroot].

Verifiquemos:

curl -i http://localhost:5000/css/styles.css
HTTP/1.1 200 OK
Content-Length: 430
Content-Type: text/css

/* algunos ajustes sobre Bootstrap */
body {
  background-color: #f5f7fa;
}

/* el pie de página del layout */
.footer {
  margin-top: 2rem;
  font-size: 0.85rem;
  color: #6c757d;
}

/* los mensajes de error, al final de la página, sobre un fondo rosa claro */
.error-area {
  margin-top: 1.5rem;
  padding: 0.75rem 1rem;
  background-color: #fdecef;
  border: 1px solid #f5c2c7;
  border-radius: 0.375rem;
  color: #842029;
}

El archivo [Views/_ViewStart.cshtml]:

1
2
3
4
@* se ejecuta antes de cada vista: todas las vistas usan el layout _Layout *@
@{
    Layout = "_Layout";
}
  • Línea 3: el archivo [_ViewStart.cshtml] se ejecuta antes de cada vista de su carpeta y subcarpetas. Establece la propiedad [Layout]: todas las vistas usan la plantilla [_Layout], que se busca en la carpeta de la vista y luego en [Views/Shared].

El archivo [Views/_ViewImports.cshtml]:

1
2
3
@* los Tag Helpers de ASP.NET Core: etiquetas HTML "enriquecidas", como <partial> *@
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@using Example15.Controllers
  • Línea 2: habilita los Tag Helpers proporcionados por [ASP.NET Core]: etiquetas o atributos HTML procesados por el servidor. La etiqueta [<partial>] es un ejemplo de ello. [*] significa “todos los Tag Helpers del ensamblado” [Microsoft.AspNetCore.Mvc.TagHelpers];
  • Línea 3: el tipo [Member] se declara en el espacio de nombres de los controladores.

El archivo [Views/Shared/_Layout.cshtml]:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  @* ViewData["Title"]: un valor asignado por la vista, leído por el layout *@
  <title>@ViewData["Title"] - My site</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3">
    <partial name="_Navbar" />
    @* aquí se inserta la vista solicitada por la acción *@
    @RenderBody()
    @* Context: la solicitud actual (HttpContext), disponible para todas las vistas *@
    <footer class="footer">Page [@Context.Request.Path] - © @DateTime.Now.Year</footer>
  </div>
</body>
</html>
  • línea 7: [ViewData] es un diccionario compartido por una vista y su plantilla (y por la acción, que también puede almacenar valores en él). La vista almacena allí su título y la plantilla lo muestra;
  • líneas 8–9: las hojas de estilo, servidas por [UseStaticFiles];
  • línea 13: inserción de la vista parcial [_Navbar], que se busca en la carpeta de la vista y luego en [Views/Shared];
  • línea 15: el lugar donde [Razor] inserta la vista solicitada por la acción;
  • línea 17: [Context] es el objeto [HttpContext] de la solicitud actual (véase el ejemplo 05), accesible desde cualquier vista: la plantilla muestra la ruta solicitada sin que cada acción tenga que transmitirla.

El archivo [Views/Shared/_Navbar.cshtml]:

1
2
3
4
5
6
7
8
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">My site</span>
  <div class="navbar-nav">
    <a class="nav-link" href="/">Home</a>
    <a class="nav-link" href="/team">Team</a>
    <a class="nav-link" href="/raw">Page without layout</a>
  </div>
</nav>

El archivo [Views/Shared/_Card.cshtml]:

1
2
3
4
5
6
7
8
@* una "card" de Bootstrap; su modelo: un Member (nombre, rol) *@
@model Member
<div class="card">
  <div class="card-body">
    <h5 class="card-title">@Model.Name</h5>
    <p class="card-text">@Model.Role</p>
  </div>
</div>

Por convención, el nombre de una vista parcial o de una plantilla comienza con [_]: no son páginas completas. La vista parcial [_Card] tiene su propio modelo (línea 2), un nombre y un rol. El tipo [Member] se declara en el controlador. El archivo [Controllers/PagesController.cs]:

using Microsoft.AspNetCore.Mvc;

namespace Example15.Controllers;

public record Member(string Name, string Role);

public class PagesController : Controller
{
    [HttpGet("/")]
    public IActionResult Home()
    {
        return View();
    }

    [HttpGet("team")]
    public IActionResult Team()
    {
        List<Member> members =
        [
            new Member("Marie Pélissier", "Director"),
            new Member("Jacques Bromard", "Developer"),
            new Member("Philippe Jandot", "Graphic designer"),
        ];
        return View(members);
    }

    [HttpGet("raw")]
    public IActionResult Raw()
    {
        return View();
    }
}
  • línea 5: el tipo de los miembros del equipo;
  • línea 12: la acción [Home] no tiene modelo: [View()] sin argumentos;
  • líneas 18–24: la acción [Team] transmite una lista de miembros.

La vista parcial se usa de dos maneras. El archivo [Views/Pages/Home.cshtml]:

1
2
3
4
5
6
7
@{
    ViewData["Title"] = "Home";
}
<h1>Welcome</h1>
<p>This page only contains its own content: the header, the navigation
  bar and the footer come from the <code>_Layout.cshtml</code> layout.</p>
<partial name="_Card" model='new Member("A partial view", "inserted with a model built on the spot")' />
  • línea 2: la vista coloca su título en [ViewData], para la plantilla;
  • Línea 7: el atributo [model] de la etiqueta [<partial>] proporciona el modelo de la vista parcial: en este caso, un objeto creado sobre la marcha. Es una expresión [C#]: se encierra entre apóstrofos para poder usar comillas dentro de ella.

El archivo [Views/Pages/Team.cshtml]:

@model List<Member>
@{
    ViewData["Title"] = "Our team";
}
<h1>Our team</h1>
<div class="row g-3">
  @foreach (var member in Model)
  {
    <div class="col-md-4">
      @* la vista parcial recibe al miembro actual como modelo *@
      <partial name="_Card" model="member" />
    </div>
  }
</div>
  • Línea 11: la vista parcial recibe la iteración actual del bucle como modelo.

El archivo [Views/Pages/Raw.cshtml]:

@* Layout = null: esta vista no usa el layout, es una página completa *@
@{
    Layout = null;
}
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Raw page</title>
</head>
<body>
  <p>This page does not use the layout: no Bootstrap, no navigation bar.</p>
  <p><a href="/">Back to home</a></p>
</body>
</html>
  • Línea 3: asignar [Layout] a [null] en una vista cancela la selección de [_ViewStart.cshtml]: la vista [Raw] es una página HTML completa. También se podría especificar otra plantilla ([Layout = "_Other"]).

Las páginas resultantes, en las URL http://localhost:5000/, http://localhost:5000/team, y http://localhost:5000/raw:

Image

Image

Image

La plantilla, las vistas parciales y [ViewData] son exactamente lo que usa el caso de estudio: una plantilla [_Layout.cshtml], vistas parciales para la barra de navegación, los mensajes y las ventanas de confirmación.

4.4. Ejemplo 16: helpers

Una vista suele necesitar pequeñas funciones de formato: dar formato a una fecha o a un precio, poner un texto en mayúsculas, crear una insignia HTML... Con [Razor], se trata de simples métodos [C#], llamados dentro de una expresión [@]. [ASP.NET Core] también ofrece los Tag Helpers: código [C#] que actúa sobre una etiqueta HTML cuando se renderiza la página.

El archivo [Helpers/Formats.cs]:

using System.Globalization;
using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Html;

namespace Example16.Helpers;

// funciones C# ordinarias, invocables desde las vistas: @Formats.Money(...)
public static class Formats
{
    // "keyboard" -> "KEYBOARD"
    public static string Uppercase(string? text) => (text ?? "").ToUpperInvariant();

    // un monto en una moneda, en el formato del idioma actual (CultureInfo.CurrentCulture)
    // "C" = moneda; el objeto NumberFormatInfo define el símbolo monetario
    public static string Money(decimal amount, string currency = "EUR")
    {
        var format = (NumberFormatInfo)CultureInfo.CurrentCulture.NumberFormat.Clone();
        format.CurrencySymbol = currency == "USD" ? "$" : "€";
        return amount.ToString("C", format);
    }

    // una fecha en palabras completas, en el idioma actual: "Wednesday, September 23, 2026"
    public static string Date(DateTime when) => when.ToString("D", CultureInfo.CurrentCulture);

    // un helper que construye HTML: devuelve un IHtmlContent, que Razor no escapa.
    // Entonces le corresponde al helper escapar los datos que inserta (HtmlEncoder)
    public static IHtmlContent Badge(int stock)
    {
        var cssClass = stock > 0 ? "text-bg-success" : "text-bg-danger";
        var text = HtmlEncoder.Default.Encode(stock > 0 ? $"{stock} in stock" : "sold out");
        return new HtmlString($"<span class=\"badge {cssClass}\">{text}</span>");
    }
}

Analicemos este código:

  • línea 8: una clase estática: sus métodos se llaman sin crear un objeto, [Formats.Uppercase(...)];
  • línea 11: conversión a mayúsculas. [ToUpperInvariant] es independiente del idioma del usuario;
  • líneas 15–19: un monto en una moneda. El formato ["C"] ([currency]) da formato a un monto según la configuración regional actual ([CultureInfo.CurrentCulture]): separador decimal, separador de miles y posición del símbolo de moneda. Las reglas de la configuración regional se copian ([Clone]) para cambiar el símbolo de moneda;
  • línea 23: una fecha escrita completa (formato ["D"]), en el idioma de la cultura actual;
  • líneas 27–31: un helper que genera HTML. El resultado de una expresión [@] se escapa, a menos que sea un [IHtmlContent]: HTML ya generado. [HtmlString] es su implementación más simple. El helper debe entonces escapar por sí mismo los datos que inserta en su HTML ([HtmlEncoder.Default.Encode]).

El archivo [TagHelpers/ActiveTagHelper.cs]:

using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Mvc.TagHelpers;
using Microsoft.AspNetCore.Razor.TagHelpers;

namespace Example16.TagHelpers;

// un Tag Helper: se aplica a las etiquetas <a> que llevan el atributo "active-path"
// <a href="/products" active-path="/products"> recibe la clase "active" si la
// página actual está bajo esta ruta
[HtmlTargetElement("a", Attributes = "active-path")]
public class ActiveTagHelper(IHttpContextAccessor accessor) : TagHelper
{
    // el valor del atributo active-path="..."
    public string ActivePath { get; set; } = "";

    public override void Process(TagHelperContext context, TagHelperOutput output)
    {
        var path = accessor.HttpContext?.Request.Path.Value ?? "/";
        var isActive = ActivePath == "/" ? path == "/" : path.StartsWith(ActivePath, StringComparison.Ordinal);
        if (isActive)
        {
            output.AddClass("active", HtmlEncoder.Default); // agrega la clase al atributo class
        }
    }
}

Analicemos este código:

  • línea 10: el Tag Helper se aplica a las etiquetas [<a>] que tienen el atributo [active-path];
  • línea 11: un Tag Helper deriva de la clase [TagHelper]. Es un servicio: recibe por inyección un [IHttpContextAccessor], que da acceso a la solicitud actual;
  • línea 14: el valor del atributo [active-path="..."] se asigna a la propiedad del mismo nombre ([ActivePath]);
  • líneas 16–22: el método [Process] se llama para cada etiqueta pertinente. Si la ruta de la página comienza con el valor del atributo, se agrega a la etiqueta la clase CSS [active] ([AddClass]). El atributo [active-path] en sí no aparece en la página generada: el Tag Helper lo ha consumido.

El archivo [Program.cs]:

using System.Globalization;
using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
// IHttpContextAccessor: da acceso a la solicitud actual (lo usa ActiveTagHelper)
builder.Services.AddHttpContextAccessor();

var app = builder.Build();

// un middleware: el idioma de formato proviene del parámetro ?lang=fr de la URL
app.Use(async (context, next) =>
{
    var language = context.Request.Query["lang"] == "fr" ? "fr-FR" : "en-US";
    CultureInfo.CurrentCulture = new CultureInfo(language);
    await next(context); // pasar el control al siguiente middleware
});

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 10: registra el servicio [IHttpContextAccessor], utilizado por el Tag Helper;
  • líneas 15–19: middleware escrito directamente en [Program.cs], ejecutado en cada solicitud. Selecciona la cultura según el parámetro [lang] de la URL y luego pasa el control al siguiente middleware ([next]). Es una forma sencilla de hacer pruebas; el siguiente capítulo lo tratará mejor.

El archivo [Views/_ViewImports.cshtml]:

1
2
3
4
5
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@* nuestros propios Tag Helpers, los del ensamblado Example16 *@
@addTagHelper *, Example16
@using Example16.Helpers
@using Example16.Controllers
  • Línea 3: habilitamos los Tag Helpers de nuestro propio proyecto (el ensamblado [Example16]);
  • línea 4: las vistas pueden escribir [Formats.Money(...)].

El archivo [Views/Shared/_Navbar.cshtml]:

<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">Helpers</span>
  <div class="navbar-nav">
    @* 1. una condición escrita en la vista *@
    <a class="nav-link @(Context.Request.Path == "/" ? "active" : "")" href="/">Home</a>
    @* 2. nuestro Tag Helper: el atributo active-path="..." *@
    <a class="nav-link" href="/products" active-path="/products">Products</a>
    @* 3. un Tag Helper de ASP.NET: asp-action construye la URL de la acción *@
    <a class="nav-link" asp-controller="Pages" asp-action="Products" asp-route-lang="fr">Produits (fr)</a>
  </div>
</nav>
  • Líneas 4–5: primera forma de resaltar el enlace de la página actual: una condición escrita en la vista;
  • línea 7: segunda forma, más concisa: nuestro Tag Helper. Es la que se usa en el caso de estudio;
  • línea 9: un Tag Helper de [ASP.NET Core]. Los atributos [asp-controller] y [asp-action] designan una acción; el Tag Helper calcula su URL a partir de las rutas (aquí, [/products]) y la escribe en el atributo [href]. [asp-route-lang="fr"] agrega un parámetro, que se coloca en la URL ([?lang=fr]) puesto que la ruta no contiene un parámetro [lang]. Si se cambia la URL de la acción, el enlace la sigue.

El código HTML de la barra de navegación, desde la URL hasta [/products]:

1
2
3
4
5
6
7
8
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">Helpers</span>
  <div class="navbar-nav">
    <a class="nav-link " href="/">Home</a>
    <a class="nav-link active" href="/products">Products</a>
    <a class="nav-link" href="/products?lang=fr">Produits (fr)</a>
  </div>
</nav>

El archivo [Views/Pages/Products.cshtml]:

@model List<Product>
@{
    ViewData["Title"] = "Products";
}
<h1>Products</h1>
<table class="table table-sm w-auto">
  <thead><tr><th>Product</th><th>Price</th><th>Price in dollars</th><th>Stock</th></tr></thead>
  <tbody>
    @foreach (var product in Model)
    {
      <tr>
        <td>@Formats.Uppercase(product.Name)</td>
        <td>@Formats.Money(product.Price)</td>
        <td>@Formats.Money(product.Price, "USD")</td>
        <td>@Formats.Badge(product.Stock)</td>
      </tr>
    }
  </tbody>
</table>
  • Líneas 12–15: los helpers se llaman dentro de expresiones [@]. [Badge] devuelve HTML, que se inserta sin escapar.

Las páginas resultantes, en inglés (http://localhost:5000/, http://localhost:5000/products) y luego en francés (http://localhost:5000/products?lang=fr):

Image

Image

Image

Los precios cambian de formato según el idioma: [1 149,90 €] en francés, [€1,149.90] en inglés.

4.5. Ejemplo 17: un formulario GET

Un formulario HTML enviado con el método GET coloca sus campos en la URL. Es el método apropiado para una búsqueda: no modifica nada, y la URL resultante se puede guardar como marcador o compartir. El caso de estudio lo usa para seleccionar un médico y una fecha.

El archivo [Models/Book.cs]:

1
2
3
4
5
6
namespace Example17.Models;

public record Book(string Title, string Author, string Genre);

// el modelo de vista: la entrada (para volver a mostrarla), los géneros, los resultados
public record SearchModel(string Keyword, string Genre, string[] Genres, List<Book> Results);
  • Línea 6: el modelo de la vista contiene los valores introducidos ([Keyword], [Genre]), para que el formulario pueda mostrarlos de nuevo, junto con la lista de géneros y los resultados.

El archivo [Controllers/BooksController.cs]:

using Example17.Models;
using Microsoft.AspNetCore.Mvc;

namespace Example17.Controllers;

public class BooksController : Controller
{
    private static readonly List<Book> Books =
    [
        new Book("Le Rouge et le Noir", "Stendhal", "novel"),
        new Book("Les Fleurs du mal", "Baudelaire", "poetry"),
        new Book("Madame Bovary", "Flaubert", "novel"),
        new Book("Alcools", "Apollinaire", "poetry"),
        new Book("Le Cid", "Corneille", "drama"),
    ];

    private static readonly string[] Genres = ["novel", "poetry", "drama"];

    // GET / y GET /search?keyword=...&genre=...: el formulario Y sus resultados
    [HttpGet("/")]
    [HttpGet("search")]
    public IActionResult Search(string? keyword, string? genre)
    {
        var word = (keyword ?? "").Trim().ToLower();
        var results = Books
            .Where(b => word == "" || b.Title.ToLower().Contains(word) || b.Author.ToLower().Contains(word))
            .Where(b => string.IsNullOrEmpty(genre) || b.Genre == genre)
            .ToList();
        return View(new SearchModel(keyword ?? "", genre ?? "", Genres, results));
    }
}
  • líneas 8–14: los libros, en memoria;
  • líneas 20–21: dos atributos de ruta: la acción procesa [GET /] y [GET /search];
  • Línea 22: los parámetros [keyword] y [genre] se enlazan con los parámetros del mismo nombre de la URL. En la primera visita, el formulario aún no se ha enviado: sus valores son [null];
  • líneas 25–28: filtrado, mediante [LINQ]. Una palabra clave vacía o una categoría vacía no filtra nada;
  • línea 29: el modelo de la vista.

El archivo [Views/Books/Search.cshtml]:

@model SearchModel
<h1 class="h3">Book search</h1>
@* method="get": los campos se envían en la URL (?keyword=...&genre=...) *@
<form method="get" action="/search" class="row g-2 align-items-end mb-3">
  <div class="col-auto">
    <label class="form-label" for="keyword">Title or author</label>
    @* value="@Model.Keyword": el campo vuelve a mostrar lo que se escribió *@
    <input class="form-control" id="keyword" name="keyword" value="@Model.Keyword">
  </div>
  <div class="col-auto">
    <label class="form-label" for="genre">Genre</label>
    <select class="form-select" id="genre" name="genre">
      <option value="">(all)</option>
      @foreach (var genre in Model.Genres)
      {
        @* un atributo booleano: se escribe si la condición es verdadera, se omite en caso contrario *@
        <option value="@genre" selected="@(genre == Model.Genre)">@genre</option>
      }
    </select>
  </div>
  <div class="col-auto">
    <button class="btn btn-primary" type="submit">Search</button>
  </div>
</form>
<p>@Model.Results.Count book(s) found.</p>
<ul>
  @foreach (var book in Model.Results)
  {
    <li><i>@book.Title</i>, @book.Author (@book.Genre)</li>
  }
</ul>
  • línea 4: [method="get"] y [action="/search"]: el envío del formulario es una solicitud [GET /search?keyword=...&genre=...]. Los nombres de los parámetros son el atributo [name] de cada campo;
  • Línea 8: el atributo [value] vuelve a mostrar lo introducido;
  • línea 17: en la lista desplegable, la opción correspondiente al género seleccionado recibe el atributo [selected]. [Razor] trata los atributos booleanos de una manera particular: si el valor es [true], escribe [selected="selected"]; si es [false], no escribe el atributo en absoluto. Esto es exactamente lo que exige HTML, para el cual basta la mera presencia del atributo [selected] para seleccionar la opción.

En la primera visualización (http://localhost:5000/) y luego de una búsqueda:

Image

Image

La barra de direcciones muestra los parámetros enviados. Los caracteres acentuados y los espacios se codifican allí ([%C3%A9]...): es la codificación de URL, que [ASP.NET Core] decodifica antes del enlace de modelo.

4.6. Ejemplo 18: campos de formulario

El ejemplo 18 incluye todos los tipos de campos HTML: texto, contraseña, fecha, botones de opción, casillas de verificación, lista desplegable, lista de selección múltiple, área de texto y campo oculto. Muestra cómo los recibe el servidor y cómo los muestra la vista.

El archivo [Services/ListsService.cs]:

namespace Example18.Services;

public record Country(string Code, string Name);

// las listas que ofrece el formulario. En una aplicación real,
// provendrían de una base de datos: las leeríamos UNA sola vez, al inicio,
// ya que son las mismas para todos los usuarios
public class ListsService
{
    public string[] Titles { get; } = ["Mr", "Mme", "Melle"];

    public Country[] Countries { get; } =
    [
        new Country("fr", "France"),
        new Country("be", "Belgium"),
        new Country("ch", "Switzerland"),
        new Country("ca", "Canada"),
    ];

    public string[] Hobbies { get; } = ["reading", "music", "sport", "cinema"];

    public string[] Languages { get; } = ["French", "English", "Spanish", "German"];
}

Las listas que ofrece el formulario las proporciona un servicio. Son las mismas para todos los usuarios: un servicio instanciado una sola vez (un singleton; véase el capítulo 6) es el lugar natural para almacenarlas. Se registra en [Program.cs]:

using System.Text.Encodings.Web;
using System.Text.Unicode;
using Example18.Services;
using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
// Razor escribe los caracteres acentuados tal cual (y no "&#xE9;");
// < > & " ' siguen escapados
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
// las listas del formulario: las mismas para todos, un único objeto (singleton)
builder.Services.AddSingleton<ListsService>();

var app = builder.Build();

// 1. los archivos estáticos de la carpeta wwwroot: wwwroot/css/styles.css se sirve como /css/styles.css
app.UseStaticFiles();
// 2. Bootstrap, compartido por los ejemplos: la carpeta examples/common/bootstrap se sirve bajo /bootstrap
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: una única instancia de [ListsService], compartida por todas las solicitudes.

El archivo [Models/Input.cs]:

namespace Example18.Models;

// lo que escribió el usuario: el enlace del modelo llena cada propiedad
// con el campo del mismo nombre (los arreglos reciben todos los valores marcados)
public class Input
{
    public string? Name { get; set; }
    public string? Password { get; set; }
    public string? Comment { get; set; }
    public string? Title { get; set; }
    public string[] Hobbies { get; set; } = [];
    public string? Country { get; set; }
    public string[] Languages { get; set; } = [];
    public DateOnly? BirthDate { get; set; }
    public string? Token { get; set; }
}

// una opción de una lista, y su estado (marcada / seleccionada)
public record Option(string Value, string Label, bool Chosen);

// el modelo de vista
public class FormModel
{
    public required Input Input { get; init; }
    public required List<Option> Titles { get; init; }
    public required List<Option> Hobbies { get; init; }
    public required List<Option> Countries { get; init; }
    public required List<Option> Languages { get; init; }
    public string? Received { get; init; } // lo que recibió el servidor, para mostrarlo
}

Comentemos este código:

  • Líneas 5–15: los datos de entrada. El enlace de modelo rellena cada propiedad con el campo del mismo nombre. Las casillas de verificación y la lista desplegable son arreglos ([string[]]): reciben todos los valores enviados (véase el ejemplo 10). La fecha de nacimiento se convierte a [DateOnly];
  • línea 19: una opción de una lista: su valor, su etiqueta y un booleano que indica si está marcada o seleccionada;
  • líneas 22–29: el modelo de la vista. La palabra clave [required] exige que la propiedad se proporcione al crear el objeto; [init] impide que se modifique después.

El archivo [Controllers/FormController.cs]:

using Example18.Models;
using Example18.Services;
using Microsoft.AspNetCore.Mvc;

namespace Example18.Controllers;

[Route("form")]
public class FormController(ListsService lists) : Controller
{
    // GET: el formulario, con valores iniciales
    [HttpGet("")]
    public IActionResult Display()
    {
        var initial = new Input { Title = "Mme", Country = "fr", Languages = ["French"], Token = "A7X2" };
        return View("Form", Model(initial, null));
    }

    // POST: el enlace del modelo llena [input]; mostramos el formulario de nuevo
    [HttpPost("")]
    public IActionResult Process(Input input)
    {
        // lo que el navegador envió realmente, campo por campo
        var received = string.Join("\n", Request.Form.Select(c => $"{c.Key} = [{string.Join(", ", c.Value.ToArray())}]"));
        return View("Form", Model(input, received));
    }

    // el modelo de vista: las listas, cada opción marcada como marcada /
    // seleccionada según la entrada. La vista solo tendrá que evaluar un booleano.
    private FormModel Model(Input input, string? received) => new()
    {
        Input = input,
        Titles = lists.Titles.Select(t => new Option(t, t, t == input.Title)).ToList(),
        Hobbies = lists.Hobbies.Select(h => new Option(h, h, input.Hobbies.Contains(h))).ToList(),
        Countries = lists.Countries.Select(c => new Option(c.Code, c.Name, c.Code == input.Country)).ToList(),
        Languages = lists.Languages.Select(l => new Option(l, l, input.Languages.Contains(l))).ToList(),
        Received = received,
    };
}

Comentemos este código:

  • línea 8: se inyecta el servicio de listas;
  • líneas 11–15: [GET /form] muestra el formulario con valores iniciales;
  • líneas 19–24: [POST /form] recibe los datos introducidos por el usuario (rellenados por el enlace de modelo) y vuelve a dibujar el formulario. [Request.Form] también da acceso a los campos tal como se enviaron: los convierte en texto, una línea por campo, para mostrarlos;
  • líneas 29–36: el modelo de la vista. Para cada lista, la acción calcula qué opciones deben estar marcadas o seleccionadas: la vista solo tendrá entonces que evaluar un booleano.

El archivo [Views/Form/Form.cshtml]:

@model FormModel
<h1 class="h3">A complete form</h1>
<form method="post" action="/form" style="max-width: 40rem">
  @* campo oculto: se envía con el formulario, pero es invisible *@
  <input type="hidden" name="token" value="@Model.Input.Token">

  <div class="mb-2">
    <span class="form-label me-3">Title</span>
    @foreach (var title in Model.Titles)
    {
      @* botones de opción (radio): mismo [name], se envía un único valor *@
      <div class="form-check form-check-inline">
        <input class="form-check-input" type="radio" name="title" id="title-@title.Value"
               value="@title.Value" checked="@title.Chosen">
        <label class="form-check-label" for="title-@title.Value">@title.Label</label>
      </div>
    }
  </div>

  <div class="row g-2 mb-2">
    <div class="col">
      <label class="form-label" for="name">Name</label>
      <input class="form-control" type="text" id="name" name="name" value="@Model.Input.Name">
    </div>
    <div class="col">
      <label class="form-label" for="password">Password</label>
      @* una contraseña NUNCA se devuelve en la página *@
      <input class="form-control" type="password" id="password" name="password">
    </div>
    <div class="col">
      <label class="form-label" for="birthDate">Date of birth</label>
      @* un campo de fecha intercambia sus valores en el formato yyyy-mm-dd *@
      <input class="form-control" type="date" id="birthDate" name="birthDate"
             value="@Model.Input.BirthDate?.ToString("yyyy-MM-dd")">
    </div>
  </div>

  <div class="mb-2">
    <span class="form-label me-3">Hobbies</span>
    @for (var i = 0; i < Model.Hobbies.Count; i++)
    {
      var hobby = Model.Hobbies[i];
      @* casillas de verificación (checkboxes): mismo [name], varios valores posibles *@
      <div class="form-check form-check-inline">
        <input class="form-check-input" type="checkbox" name="hobbies" id="hobby-@i"
               value="@hobby.Value" checked="@hobby.Chosen">
        <label class="form-check-label" for="hobby-@i">@hobby.Label</label>
      </div>
    }
  </div>

  <div class="row g-2 mb-2">
    <div class="col">
      <label class="form-label" for="country">Country</label>
      <select class="form-select" id="country" name="country">
        @foreach (var country in Model.Countries)
        {
          <option value="@country.Value" selected="@country.Chosen">@country.Label</option>
        }
      </select>
    </div>
    <div class="col">
      <label class="form-label" for="languages">Spoken languages</label>
      @* lista de selección múltiple: varios valores posibles *@
      <select class="form-select" id="languages" name="languages" multiple size="4">
        @foreach (var language in Model.Languages)
        {
          <option value="@language.Value" selected="@language.Chosen">@language.Label</option>
        }
      </select>
    </div>
  </div>

  <div class="mb-2">
    <label class="form-label" for="comment">Comment</label>
    @* un área de texto: el valor va ENTRE las etiquetas *@
    <textarea class="form-control" id="comment" name="comment" rows="2">@Model.Input.Comment</textarea>
  </div>

  <button class="btn btn-primary" type="submit">Send</button>
</form>

@if (Model.Received is not null)
{
  <h2 class="h5 mt-3">What the server received</h2>
  <pre class="bg-light p-2 border">@Model.Received</pre>
}

Comentemos este código:

  • Línea 3: el formulario se envía mediante POST: sus campos se incluyen en el cuerpo de la solicitud;
  • Línea 5: un campo oculto se envía con el formulario pero no se muestra. Sirve para transmitir información de una página a la siguiente (en el caso de estudio, por ejemplo, contiene la versión de un registro). Atención: el usuario puede modificarlo;
  • Líneas 9–15: los botones de opción comparten el mismo [name]; solo uno puede estar seleccionado y solo se envía un valor. El atributo booleano [checked="@title.Chosen"] selecciona el botón (véase [selected], ejemplo 17);
  • línea 28: una contraseña nunca se reenvía en una página: el campo no tiene atributo [value];
  • líneas 33–34: un campo de fecha. El navegador muestra la fecha en el formato del usuario, pero siempre envía y recibe [yyyy-mm-dd];
  • líneas 40–46: casillas de verificación con el mismo atributo [name]: cada casilla marcada envía su valor; el parámetro se repite, por tanto;
  • líneas 55–60: una lista desplegable. La opción seleccionada tiene el atributo [selected];
  • línea 65: el atributo [multiple] permite seleccionar varias opciones;
  • línea 77: el valor de un área de texto se coloca entre sus etiquetas, no en un atributo [value];
  • Líneas 83–86: lo que recibió el servidor, mostrado dentro de una etiqueta [<pre>], que conserva los saltos de línea.

El formulario inicial (http://localhost:5000/form) y luego del envío:

Image

Image

Observe que el área de texto volvió a mostrar [Hello <b>everyone</b>] exactamente como se introdujo: gracias al escape de las expresiones [@], las etiquetas introducidas no se interpretan. La contraseña se recibió, pero no se muestra. Con [curl], podemos ver la diferencia cuando se marca una casilla:

curl -d "token=A7X2&title=Mr&name=Martin&hobbies=sport" http://localhost:5000/form
1
2
3
4
token = [A7X2]
title = [Mr]
name = [Martin]
hobbies = [sport]

y con dos casillas marcadas:

curl -d "token=A7X2&title=Mr&name=Martin&hobbies=sport&hobbies=music" http://localhost:5000/form
1
2
3
4
token = [A7X2]
title = [Mr]
name = [Martin]
hobbies = [sport, music]

(solo se reproduce el contenido de la etiqueta [<pre>] de la página, tal como lo muestra un navegador). Una casilla sin marcar no se envía en absoluto: [Request.Form] no contiene el campo, y la propiedad [Hobbies] de los datos de entrada conserva su valor inicial: el arreglo vacío.

4.7. Ejemplo 19: validación de formularios

Un formulario inválido debe mostrarse de nuevo, con los valores introducidos y un mensaje debajo de cada campo con error. El ejemplo 19 aplica la técnica del ejemplo 09 (validación realizada por la acción, mediante [ModelState]) a un formulario de registro.

El archivo [Models/RegistrationModel.cs]:

using System.ComponentModel.DataAnnotations;

namespace Example19.Models;

// los campos del formulario y sus restricciones
public class RegistrationModel
{
    // elimina los espacios sobrantes de una entrada (el "setter" lo invoca el enlace del modelo)
    private string? name;

    [Required(ErrorMessage = "The name is required.")]
    [MaxLength(20, ErrorMessage = "The name must not exceed 20 characters.")]
    public string? Name
    {
        get => name;
        set => name = value?.Trim();
    }

    [Required(ErrorMessage = "The email address is required.")]
    [EmailAddress(ErrorMessage = "Invalid email address.")]
    public string? Email { get; set; }

    // todo lo que proviene de un formulario es una cadena: "42" -> 42
    [Required(ErrorMessage = "The age is required.")]
    [Range(18, 120, ErrorMessage = "The age must be between 18 and 120 years.")]
    public int? Age { get; set; }

    [Required(ErrorMessage = "The password is required.")]
    [MinLength(6, ErrorMessage = "The password must have at least 6 characters.")]
    public string? Password { get; set; }

    // una regla sobre DOS campos: [Compare] compara con Password
    [Compare(nameof(Password), ErrorMessage = "The confirmation does not match the password.")]
    public string? Confirmation { get; set; }
}

// el modelo de vista: los valores que se mostrarán de nuevo, los errores por campo
public class RegistrationForm
{
    public RegistrationModel Values { get; init; } = new();
    public Dictionary<string, string> Errors { get; init; } = new(StringComparer.OrdinalIgnoreCase);
    public bool Html5 { get; init; }
}

// el modelo de la vista parcial _Field: un campo de entrada
public record FieldModel(string Name, string Label, string Type, string? Value, string? Error, string Attributes);

Comentemos este código:

  • Líneas 9–16: una propiedad con un campo privado. Su descriptor de acceso [set], llamado por el enlace de modelo, elimina los espacios innecesarios de lo introducido: [" Martin "] se convierte en ["Martin"]. Un nombre compuesto únicamente por espacios es convertido a [null] por el propio enlace de modelo, y [[Required]] lo rechaza;
  • línea 12: [[MaxLength]] limita la longitud de una cadena, igual que [[StringLength]];
  • Líneas 25–26: la edad se convierte a entero y luego se valida;
  • línea 29: al menos 6 caracteres;
  • línea 33: la regla “la confirmación coincide con la contraseña” se aplica a dos campos. El atributo [[Compare]] compara la propiedad que decora con otra propiedad, designada por su nombre ([nameof(Password)]: el nombre de la propiedad, verificado por el compilador);
  • líneas 38–42: el modelo de la vista: los valores que se deben mostrar de nuevo, los errores ordenados por campo (un diccionario cuyas claves no distinguen mayúsculas de minúsculas) y un booleano que se explicará más adelante;
  • línea 46: el modelo de la vista parcial que muestra un campo.

El archivo [Controllers/RegistrationController.cs]:

using Example19.Models;
using Microsoft.AspNetCore.Mvc;

namespace Example19.Controllers;

[Route("register")]
public class RegistrationController : Controller
{
    // ?html5=1: dejamos que el navegador valide el formulario antes de enviarlo
    [HttpGet("")]
    public IActionResult Display(bool html5)
    {
        return View("Registration", new RegistrationForm { Html5 = html5 });
    }

    [HttpPost("")]
    public IActionResult Register(RegistrationModel input, [FromQuery] bool html5)
    {
        if (!ModelState.IsValid)
        {
            // los errores por campo, para mostrar cada mensaje bajo su campo
            var errors = ModelState
                .Where(c => c.Value!.Errors.Count > 0)
                .ToDictionary(c => c.Key, c => c.Value!.Errors[0].ErrorMessage, StringComparer.OrdinalIgnoreCase);
            // mostramos el formulario DE NUEVO: valores escritos (excepto las contraseñas),
            // y un mensaje bajo cada campo inválido
            input.Password = input.Confirmation = null;
            ViewData["Error"] = "The form contains errors.";
            return View("Registration", new RegistrationForm { Values = input, Errors = errors, Html5 = html5 });
        }
        return View("Welcome", input);
    }
}

Comentemos este código:

  • Líneas 11–13: el formulario vacío. El parámetro [html5] se explicará más adelante;
  • Línea 17: el enlace de modelo rellena [input] con los campos del formulario y lo valida. [[FromQuery]] obtiene [html5] de la URL;
  • Líneas 19–24: si hay errores, se organizan por campo. Un campo puede incumplir varias restricciones: solo se conserva el primer mensaje de error ([Errors[0]]);
  • líneas 27–29: el formulario se muestra de nuevo: los valores introducidos (excepto las contraseñas), los errores por campo y un mensaje general, almacenado en [ViewData] para la plantilla;
  • línea 31: en caso contrario, la página de bienvenida, con los valores convertidos (la edad es un número, el nombre ha sido depurado).

Un error de conversión (una edad [abc]) genera de forma predeterminada un mensaje en inglés: [The value 'abc' is not valid for Age.] (véase el ejemplo 08). El archivo [Program.cs] lo reemplaza:

using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews(options =>
{
    // los mensajes de los errores de CONVERSIÓN (p. ej. edad "abc"), que reemplazan a los predeterminados
    var messages = options.ModelBindingMessageProvider;
    messages.SetAttemptedValueIsInvalidAccessor((value, field) => $"The value [{value}] is not valid.");
    messages.SetValueMustNotBeNullAccessor(field => "This field is required.");
});
// Razor escribe los caracteres acentuados tal cual (y no "&#xE9;");
// < > & " ' siguen escapados
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));

var app = builder.Build();

// 1. los archivos estáticos de la carpeta wwwroot: wwwroot/css/styles.css se sirve como /css/styles.css
app.UseStaticFiles();
// 2. Bootstrap, compartido por los ejemplos: la carpeta examples/common/bootstrap se sirve bajo /bootstrap
app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
    RequestPath = "/bootstrap",
});

app.MapControllers();
app.Run();
  • Líneas 6–11: los mensajes de los errores de enlace de modelo los proporciona el objeto [ModelBindingMessageProvider] de las opciones de MVC. Cada método [Set...Accessor] reemplaza uno de ellos por una función que genera el mensaje. [SetAttemptedValueIsInvalidAccessor] se ocupa de un valor que no se puede convertir; recibe el valor y el nombre del campo. El caso de estudio reemplaza así todos estos mensajes.

Todos los campos se construyen con el mismo modelo: una vista parcial los factoriza. El archivo [Views/Shared/_Field.cshtml]:

@* un campo de entrada; su modelo: nombre, etiqueta, tipo, valor, error y los
   atributos de validación HTML5 (required, maxlength...) *@
@model FieldModel
<div class="mb-2">
  <label class="form-label" for="@Model.Name">@Model.Label</label>
  <input class="form-control @(Model.Error is null ? "" : "is-invalid")" id="@Model.Name" name="@Model.Name"
         type="@Model.Type" value="@Model.Value" @Html.Raw(Model.Attributes)>
  @if (Model.Error is not null)
  {
    <div class="invalid-feedback">@Model.Error</div>
  }
</div>
  • línea 6: la clase [Bootstrap] [is-invalid] resalta en rojo un campo inválido;
  • línea 7: los atributos de validación HTML5 se pasan como parámetros y se insertan sin escapar ([Html.Raw]): los escribe el desarrollador, no los introduce el usuario;
  • línea 10: el mensaje de error, debajo del campo (clase [Bootstrap] [invalid-feedback]).

El archivo [Views/Registration/Registration.cshtml]:

@model RegistrationForm
@{
    // el error de un campo, o null
    string? Error(string field) => Model.Errors.GetValueOrDefault(field);
}
<h1 class="h3">Registration</h1>
@if (Model.Html5)
{
  <p>Browser validation <b>enabled</b> - <a href="/register">disable it</a></p>
}
else
{
  <p>Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>
}
@* novalidate: el navegador ignora los atributos required, min... y
   envía el formulario tal cual; solo el servidor valida *@
<form method="post" action="/register@(Model.Html5 ? "?html5=true" : "")" novalidate="@(!Model.Html5)">
  <partial name="_Field" model='new FieldModel("name", "Name", "text", Model.Values.Name, Error("name"), "required maxlength=\"20\"")' />
  <partial name="_Field" model='new FieldModel("email", "Email address", "email", Model.Values.Email, Error("email"), "required")' />
  <partial name="_Field" model='new FieldModel("age", "Age", "number", Model.Values.Age?.ToString(), Error("age"), "required min=\"18\" max=\"120\"")' />
  <partial name="_Field" model='new FieldModel("password", "Password", "password", null, Error("password"), "required minlength=\"6\"")' />
  <partial name="_Field" model='new FieldModel("confirmation", "Confirmation", "password", null, Error("confirmation"), "required")' />
  <button class="btn btn-primary" type="submit">Register</button>
</form>
  • línea 4: una función local [C#], declarada en el bloque [@{ }]: devuelve el error de un campo, o [null];
  • línea 17: el atributo booleano [novalidate] se establece cuando [Html5] es falso;
  • Líneas 18–22: cada campo es una inserción de la vista parcial, con un modelo generado sobre la marcha.

El archivo [Views/Shared/_Layout.cshtml]:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Registration</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: 36rem">
    @RenderBody()
    @* el error global, al final de la página, sobre un fondo rosa claro;
       ViewData["Error"] es asignado por la acción *@
    @if (ViewData["Error"] is string error)
    {
      <div class="error-area" role="alert">@error</div>
    }
  </div>
</body>
</html>
  • líneas 14–16: el mensaje global se muestra al pie de la página sobre un fondo rosa claro (clase [error-area] definida en [wwwroot/css/styles.css]), como en el caso de estudio. [is string error] comprueba el tipo del valor y lo almacena en una variable.

Enviemos el formulario (http://localhost:5000/register) con varios errores:

Image

y luego rellenado correctamente (con espacios alrededor del nombre):

Image

Y con una edad no numérica, enviada mediante [curl] (el navegador la habría rechazado en un campo [type="number"]):

curl -i -d "name=Martin&email=xx&age=abc" http://localhost:5000/register
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Registration</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: 36rem">
    <h1 class="h3">Registration</h1>
  <p>Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>
<form method="post" action="/register" novalidate="novalidate">
  <div class="mb-2">
  <label class="form-label" for="name">Name</label>
  <input class="form-control " id="name" name="name"
         type="text" value="Martin" required maxlength="20">
</div>

  <div class="mb-2">
  <label class="form-label" for="email">Email address</label>
  <input class="form-control is-invalid" id="email" name="email"
         type="email" value="xx" required>
    <div class="invalid-feedback">Invalid email address.</div>
</div>

  <div class="mb-2">
  <label class="form-label" for="age">Age</label>
  <input class="form-control is-invalid" id="age" name="age"
         type="number" required min="18" max="120">
    <div class="invalid-feedback">The value [abc] is not valid.</div>
</div>

  <div class="mb-2">
  <label class="form-label" for="password">Password</label>
  <input class="form-control is-invalid" id="password" name="password"
         type="password" required minlength="6">
    <div class="invalid-feedback">The password is required.</div>
</div>

  <div class="mb-2">
  <label class="form-label" for="confirmation">Confirmation</label>
  <input class="form-control " id="confirmation" name="confirmation"
         type="password" required>
</div>

  <button class="btn btn-primary" type="submit">Register</button>
</form>

      <div class="error-area" role="alert">The form contains errors.</div>
  </div>
</body>
</html>

4.7.1. Validación por el navegador

Los atributos [required], [maxlength], [min], [max], [type="email"]... indican al navegador que valide el formulario antes de enviarlo: el usuario recibe un aviso inmediato mediante un globo de ayuda, sin ningún intercambio con el servidor. Este es el comportamiento que se obtiene al hacer clic en el enlace “enable it” (http://localhost:5000/register?html5=true), que elimina el atributo [novalidate] del formulario.

Esta validación es una comodidad, no una medida de seguridad: se puede eludir simplemente eliminando el atributo [required] con las herramientas para desarrolladores del navegador, o enviando la solicitud con [curl]. La validación en el servidor sigue siendo indispensable. Por eso el ejemplo desactiva de forma predeterminada la validación del navegador: para mostrar cómo funciona el servidor. El caso de estudio, en cambio, conserva ambas: el atributo HTML5 por comodidad y la validación en el servidor por seguridad.

4.8. Ejemplo 20: el patrón Post/Redirect/Get

Cuando un formulario POST se envía con éxito, la acción puede mostrar directamente una página. El problema surge si el usuario actualiza luego esa página (tecla F5): el navegador reenvía el formulario y la operación se realiza por segunda vez (un pedido hecho dos veces, una cita agendada dos veces...). El patrón Post / Redirect / Get (PRG) evita este problema: una acción POST exitosa no genera una página; en su lugar, redirige a una página GET. Volver a cargar esta página solo desencadena otro GET, sin efecto alguno.

Queda un detalle: la página GET debe mostrar un mensaje (“la tarea ha sido agregada”), aunque este mensaje lo haya generado la acción POST en otra solicitud. Para resolverlo, [ASP.NET Core] ofrece [TempData]: un diccionario cuyo contenido persiste hasta la siguiente solicitud y desaparece en cuanto se lee. Es un mensaje flash. De forma predeterminada, [TempData] se almacena en una cookie cifrada por el servidor.

El archivo [Services/TasksService.cs]:

namespace Example20.Services;

// la lista de tareas, en memoria, compartida por todos (singleton)
public class TasksService
{
    private readonly List<string> tasks = ["Read chapter 3"];

    public IReadOnlyList<string> List() => tasks;

    public void Add(string label) => tasks.Add(label);
}

El archivo [Controllers/TasksController.cs]:

using Example20.Services;
using Microsoft.AspNetCore.Mvc;

namespace Example20.Controllers;

[Route("tasks")]
public class TasksController(TasksService tasks) : Controller
{
    // GET /tasks: la lista y el formulario de agregado
    [HttpGet("")]
    public IActionResult Display()
    {
        return View("Tasks", tasks.List());
    }

    // POST /tasks: el patrón Post / Redirect / Get
    [HttpPost("")]
    public IActionResult Add(string? label)
    {
        var text = (label ?? "").Trim();
        if (text == "" || text.Length > 40)
        {
            // entrada inválida: mostramos la página de nuevo, sin redirección
            ViewData["Label"] = label;
            ViewData["Error"] = "The label must have 1 to 40 characters.";
            return View("Tasks", tasks.List());
        }
        tasks.Add(text);
        // TempData: un mensaje que sobrevivirá a la redirección, para la SIGUIENTE solicitud
        TempData["Flash"] = $"The task [{text}] has been added.";
        // sin página: una redirección a la página GET
        return RedirectToAction(nameof(Display));
    }

    // POST /tasks/without-prg: el contraejemplo (una página como respuesta al POST)
    [HttpPost("without-prg")]
    public IActionResult AddWithoutPrg(string? label)
    {
        tasks.Add(string.IsNullOrWhiteSpace(label) ? "(untitled)" : label.Trim());
        ViewData["WithoutPrg"] = true;
        return View("Tasks", tasks.List());
    }
}

Analicemos este código:

  • líneas 11–13: la página de lista;
  • líneas 21–26: una entrada inválida: la página se vuelve a cargar (sin redirección: la entrada y el mensaje de error deben conservarse);
  • líneas 28–32: una entrada válida: la operación, el mensaje flash en [TempData] y luego una redirección 302 a la acción [Display]. [RedirectToAction] calcula la URL de la acción a partir de su ruta (véase el ejemplo 04). [nameof(Display)] es el nombre del método, validado por el compilador;
  • líneas 36–41: el contraejemplo, para comparar.

El archivo [Views/Tasks/Tasks.cshtml]:

@model IReadOnlyList<string>
<h1 class="h3">My tasks</h1>
<ol>
  @foreach (var task in Model)
  {
    <li>@task</li>
  }
</ol>
<form method="post" action="/tasks" class="d-flex gap-2">
  <input class="form-control" name="label" value="@ViewData["Label"]" placeholder="New task">
  <button class="btn btn-primary text-nowrap" type="submit">Add</button>
  @* formaction: este botón envía el MISMO formulario a otra dirección *@
  <button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
</form>
@if (ViewData["WithoutPrg"] is true)
{
  <p class="text-danger mt-2">Page displayed in response to a POST: press F5 and the task will be added a second time.</p>
}
  • línea 13: el atributo [formaction] de un botón envía el formulario a una dirección distinta de la especificada por el atributo [action] del formulario. El formulario tiene así dos botones, que desencadenan dos acciones diferentes. El caso de estudio usa este enfoque en su página de inicio de sesión.

El archivo [Views/Shared/_Layout.cshtml]:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Tasks</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: 36rem">
    @* el mensaje flash, en la parte superior de la página: LEERLO lo elimina de TempData *@
    @if (TempData["Flash"] is string flash)
    {
      <div class="alert alert-success" role="status">@flash</div>
    }
    @RenderBody()
    @if (ViewData["Error"] is string error)
    {
      <div class="error-area" role="alert">@error</div>
    }
  </div>
</body>
</html>

El mensaje flash se muestra en la parte superior de la página (líneas 12–14) y el mensaje de error en la parte inferior (líneas 17–19). Leer [TempData["Flash"]] marca el valor como consumido: se borra al final de la solicitud.

Esto es lo que ve [curl] cuando el formulario se envía con éxito. La opción [-c file] guarda las cookies recibidas, [-b file] las reenvía; [--data-urlencode] codifica los espacios y los acentos en el campo:

curl -i -c cookies.txt -b cookies.txt --data-urlencode "label=Review ASP.NET" http://localhost:5000/tasks
1
2
3
4
HTTP/1.1 302 Found
Content-Length: 0
Location: /tasks
Set-Cookie: .AspNetCore.Mvc.CookieTempDataProvider=CfDJ8Mr17zLSwO9AhYlPOJdkD8mjtY...; path=/; samesite=lax; httponly

La respuesta es una redirección, con la cookie [.AspNetCore.Mvc.CookieTempDataProvider], que contiene el mensaje flash cifrado (su valor, muy largo, se ha truncado). La siguiente solicitud envía la cookie; la respuesta la elimina (fecha de expiración en el pasado):

curl -i -c cookies.txt -b cookies.txt http://localhost:5000/tasks
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Set-Cookie: .AspNetCore.Mvc.CookieTempDataProvider=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; samesite=lax; httponly

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Tasks</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: 36rem">
      <div class="alert alert-success" role="status">The task [Review ASP.NET] has been added.</div>
    <h1 class="h3">My tasks</h1>
<ol>
    <li>Read chapter 3</li>
    <li>Review ASP.NET</li>
</ol>
<form method="post" action="/tasks" class="d-flex gap-2">
  <input class="form-control" name="label" placeholder="New task">
  <button class="btn btn-primary text-nowrap" type="submit">Add</button>
  <button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
</form>

  </div>
</body>
</html>

En el navegador (http://localhost:5000/tasks), después de agregar una tarea:

Image

La barra de direcciones muestra [/tasks]: es la página GET. Se puede recargar sin riesgo; el mensaje desaparece. Una entrada vacía:

Image

Y el contraejemplo:

Image

Aquí, recargar la página provoca una advertencia del navegador (“Confirm form submission”) y luego agrega la tarea por segunda vez. Todos los formularios POST del caso de estudio siguen el patrón PRG.

4.9. Ejemplo 21: enlaces, botones y confirmación

Una regla simple guía la elección entre un enlace y un botón:

  • un enlace ([<a href>]) genera una solicitud GET. Una solicitud GET no debe modificar nada: los navegadores, los motores de búsqueda y los antivirus pueden seguir los enlaces por su cuenta para preparar o analizar una página;
  • una operación que modifica datos (agregar, editar, eliminar, cerrar sesión) es un botón en un formulario POST.

El ejemplo 21 gestiona una lista de contactos: se puede ver un contacto haciendo clic en un enlace y eliminarlo haciendo clic en un botón, que abre una ventana de confirmación. Los archivos de este ejemplo:

21-links-buttons/
├── Controllers/
│   └── ContactsController.cs
├── Services/
│   └── ContactsService.cs
├── Views/
│   ├── Contacts/
│   │   ├── Details.cshtml
│   │   └── List.cshtml
│   ├── Shared/
│   │   ├── _Confirmation.cshtml
│   │   └── _Layout.cshtml
│   ├── _ViewImports.cshtml
│   └── _ViewStart.cshtml
├── wwwroot/
│   ├── css/
│   │   └── styles.css
│   └── js/
│       └── app.js
├── appsettings.json
├── Example21.csproj
└── Program.cs

El archivo [Services/ContactsService.cs]:

namespace Example21.Services;

// un contacto: un identificador, un nombre, un número de teléfono
public record Contact(int Id, string Name, string Phone);

// los contactos, en memoria, compartidos por todos (singleton)
public class ContactsService
{
    private readonly List<Contact> contacts =
    [
        new(1, "Marie Durand", "01 23 45 67 89"),
        new(2, "Paul Martin", "06 12 34 56 78"),
        new(3, "Philippe Jandot", "02 98 76 54 32"),
    ];
    private int lastId = 3;

    public IReadOnlyList<Contact> List() => contacts;

    // null si el contacto no existe
    public Contact? Read(int id) => contacts.Find(c => c.Id == id);

    public Contact? Edit(int id, string name, string phone)
    {
        var index = contacts.FindIndex(c => c.Id == id);
        if (index < 0) return null;
        // un record es inmutable: lo reemplazamos por una copia modificada (con with)
        contacts[index] = contacts[index] with { Name = name, Phone = phone };
        return contacts[index];
    }

    public Contact Add(string name, string phone)
    {
        var contact = new Contact(++lastId, name, phone);
        contacts.Add(contact);
        return contact;
    }

    public Contact? Delete(int id)
    {
        var contact = Read(id);
        if (contact is not null) contacts.Remove(contact);
        return contact;
    }
}
  • Línea 4: un contacto;
  • línea 20: [Find] devuelve [null] si ningún contacto tiene ese identificador;
  • líneas 22–28: un [record] es inmutable: sus propiedades no se modifican; en su lugar, se reemplaza por una copia modificada. La expresión [with { ... }] crea esta copia;
  • líneas 31–35: [++lastId] incrementa el contador antes de usarlo: los identificadores son 4, 5...

El archivo [Controllers/ContactsController.cs]:

using Example21.Services;
using Microsoft.AspNetCore.Mvc;

namespace Example21.Controllers;

[Route("contacts")]
public class ContactsController(ContactsService contacts) : Controller
{
    // un ENLACE (<a href>): una solicitud GET, que no modifica nada
    [HttpGet("")]
    public IActionResult List()
    {
        return View(contacts.List());
    }

    [HttpGet("{id:int}")]
    public IActionResult Details(int id)
    {
        var contact = contacts.Read(id);
        return contact is null ? NotFound() : View(contact);
    }

    // un BOTÓN en un formulario POST: una solicitud que modifica datos
    [HttpPost("{id:int}")]
    public IActionResult Save(int id, string name, string phone)
    {
        var contact = contacts.Edit(id, name, phone);
        if (contact is null) return NotFound();
        TempData["Flash"] = $"The contact [{contact.Name}] has been edited.";
        return RedirectToAction(nameof(List));
    }

    // el mismo formulario, otro botón (atributo formaction): otra acción
    [HttpPost("{id:int}/duplicate")]
    public IActionResult Duplicate(int id, string name, string phone)
    {
        var copy = contacts.Add($"{name} (copy)", phone);
        TempData["Flash"] = $"The contact [{copy.Name}] has been created.";
        return RedirectToAction(nameof(List));
    }

    [HttpPost("{id:int}/delete")]
    public IActionResult Delete(int id)
    {
        var contact = contacts.Delete(id);
        if (contact is null) return NotFound();
        TempData["Flash"] = $"The contact [{contact.Name}] has been deleted.";
        return RedirectToAction(nameof(List));
    }
}

Comentemos este código:

  • líneas 11–20: las dos páginas: la lista y el detalle del contacto. La restricción de ruta [:int] (véase el ejemplo 02) solo acepta un identificador entero; un contacto inexistente produce un error 404;
  • líneas 24–30: el guardado de un registro, mediante PRG;
  • líneas 34–39: la duplicación, desencadenada por un segundo botón del mismo formulario (atributo [formaction]);
  • líneas 42–48: la eliminación, mediante POST.

El archivo [Views/Contacts/List.cshtml]:

@model IReadOnlyList<Contact>
<h1 class="h3">Contacts</h1>
<table class="table align-middle">
  <tbody>
    @foreach (var contact in Model)
    {
      <tr>
        <td>@contact.Name</td>
        <td>@contact.Phone</td>
        <td class="text-end">
          @* ver: un simple enlace *@
          <a class="btn btn-sm btn-outline-primary" href="/contacts/@contact.Id">View</a>
          @* eliminar: un formulario POST, cuyo envío será confirmado *@
          <form method="post" action="/contacts/@contact.Id/delete" class="d-inline"
                data-confirmation="Delete the contact @contact.Name?">
            <button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
          </form>
        </td>
      </tr>
    }
  </tbody>
</table>
  • línea 12: ver: un enlace, mostrado como botón por [Bootstrap];
  • líneas 14–17: eliminar: un pequeño formulario (POST), reducido a su botón. El atributo [data-confirmation] contiene la pregunta que debe hacerse antes del envío. Los atributos [data-*] son opcionales: HTML los ignora, mientras que el código [JavaScript] de la página puede leerlos.

El archivo [Views/Contacts/Details.cshtml]:

@model Contact
<h1 class="h3">Contact no. @Model.Id</h1>
<form method="post" action="/contacts/@Model.Id">
  <div class="mb-2">
    <label class="form-label" for="name">Name</label>
    <input class="form-control" id="name" name="name" value="@Model.Name">
  </div>
  <div class="mb-3">
    <label class="form-label" for="phone">Phone</label>
    <input class="form-control" id="phone" name="phone" value="@Model.Phone">
  </div>
  @* dos botones de envío para el mismo formulario *@
  <button class="btn btn-primary" type="submit">Save</button>
  <button class="btn btn-outline-primary" type="submit" formaction="/contacts/@Model.Id/duplicate">Duplicate</button>
  <a class="btn btn-link" href="/contacts">Back to the list</a>
</form>
  • Líneas 13–14: dos botones de envío para el mismo formulario.

4.9.1. La ventana de confirmación

El cuadro de diálogo del navegador ([window.confirm]) no se puede personalizar ni traducir: sus botones permanecen en el idioma del navegador. Se reemplaza por una ventana [Bootstrap] integrada en la página y oculta hasta que se necesite. El archivo [Views/Shared/_Confirmation.cshtml]:

@* una sola ventana para toda la página, oculta (d-none) al inicio *@
<div id="confirmation-modal" class="d-none">
  <div class="modal-backdrop fade show"></div>
  <div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true">
    <div class="modal-dialog modal-dialog-centered">
      <div class="modal-content">
        <div class="modal-header">
          <h5 class="modal-title">Confirmation</h5>
        </div>
        <div class="modal-body">
          <p class="mb-0" id="confirmation-modal-message"></p>
        </div>
        <div class="modal-footer">
          <button type="button" class="btn btn-secondary" data-action="no">No, go back</button>
          <button type="button" class="btn btn-danger" data-action="yes">Yes, confirm</button>
        </div>
      </div>
    </div>
  </div>
</div>
  • línea 2: la clase [d-none] oculta la ventana;
  • línea 3: el fondo gris;
  • línea 11: la posición de la pregunta;
  • líneas 14–15: los dos botones, identificados por el atributo [data-action].

El archivo [Views/Shared/_Layout.cshtml]:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Contacts</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">
    @if (TempData["Flash"] is string flash)
    {
      <div class="alert alert-success" role="status">@flash</div>
    }
    @RenderBody()
  </div>
  @* la ventana de confirmación, presente en todas las páginas *@
  <partial name="_Confirmation" />
  @* el script, al final de la página: los elementos que busca ya existen *@
  <script src="/js/app.js"></script>
</body>
</html>
  • línea 18: la ventana está presente en todas las páginas;
  • línea 20: el script se carga al final de la página; cuando se ejecuta, los elementos que busca ya existen. Lo sirve [UseStaticFiles] desde [wwwroot/js/app.js].

Una pequeña porción de [JavaScript] vincula los formularios con la ventana. El archivo [wwwroot/js/app.js]:

// confirmación de los formularios que llevan el atributo data-confirmation="..."
// Sin JavaScript, estos formularios simplemente se envían sin confirmación.
(() => {
  const modal = document.getElementById('confirmation-modal');
  const message = document.getElementById('confirmation-modal-message');
  let pending = null; // el formulario que se enviará si el usuario confirma

  // 1. interceptamos el envío de los formularios que requieren confirmación
  document.querySelectorAll('form[data-confirmation]').forEach((form) => {
    form.addEventListener('submit', (event) => {
      event.preventDefault(); // el envío queda suspendido
      pending = form;
      message.textContent = form.dataset.confirmation;
      modal.classList.remove('d-none'); // aparece la ventana
    });
  });

  // 2. los dos botones de la ventana
  modal.addEventListener('click', (event) => {
    const action = event.target.dataset.action;
    if (action === 'yes') {
      pending.submit(); // envío, SIN disparar de nuevo el evento 'submit'
    } else if (action === 'no') {
      modal.classList.add('d-none');
      pending = null;
    }
  });
})();
  • línea 3: el código está envuelto en una función que se ejecuta inmediatamente, para evitar crear variables globales;
  • líneas 9–14: se intercepta el envío de cada formulario que tiene el atributo [data-confirmation]. [preventDefault()] suspende el envío; se guarda el formulario, se coloca la pregunta en la ventana ([textContent], no [innerHTML]: la pregunta se muestra como texto, nunca se interpreta como HTML) y se muestra la ventana;
  • Líneas 19–25: “Yes” envía el formulario guardado. El método [submit()] de un formulario lo envía sin desencadenar el evento [submit]: no hay una nueva solicitud de confirmación. “No” oculta la ventana.

Si [JavaScript] está desactivado, los formularios simplemente se envían sin confirmación: la aplicación sigue funcionando. Este es el principio de mejora progresiva: [JavaScript] aporta comodidad, pero no es esencial. El caso de estudio sigue este principio (su script, [wwwroot/js/app.js], agrega el manejo del teclado: la tecla Esc y el foco). Las páginas resultantes, generadas a partir de http://localhost:5000/contacts: la lista, la solicitud de confirmación, la lista tras la eliminación y el perfil de un contacto:

Image

Image

Image

Image

Por último, verificamos que la eliminación no se pueda desencadenar con una consulta GET:

curl -i http://localhost:5000/contacts/2/delete
1
2
3
HTTP/1.1 405 Method Not Allowed
Content-Length: 0
Allow: POST

La ruta existe, pero no para el método GET: [ASP.NET Core] devuelve [405 Method Not Allowed], y el encabezado [Allow] indica el método aceptado. Con POST:

curl -i -X POST http://localhost:5000/contacts/2/delete
1
2
3
4
HTTP/1.1 302 Found
Content-Length: 0
Location: /contacts
Set-Cookie: .AspNetCore.Mvc.CookieTempDataProvider=CfDJ8Mr17zLSwO9AhYlPOJdkD8nJg8...; path=/; samesite=lax; httponly