Skip to content

6. Ámbitos de los datos

Una aplicación web atiende a muchos usuarios a la vez, y cada usuario realiza numerosas solicitudes. Por lo tanto, los datos se pueden compartir en tres niveles, conocidos como su ámbito:

  • ámbito de aplicación: los datos los comparten todos los usuarios durante toda la vida del servidor (la lista de médicos, por ejemplo);
  • ámbito de solicitud: los datos existen solo mientras dura una solicitud (el modelo de una vista);
  • ámbito de cliente: los datos son específicos de un usuario y deben persistir de una solicitud a la siguiente (el idioma seleccionado, el usuario conectado).

El curso original ([ASP.NET MVC], 2013) usaba una sesión para este último ámbito: un espacio de memoria, mantenido por el servidor, específico de cada navegador. [ASP.NET Core] sigue utilizando este enfoque ([AddSession]), pero este documento, al igual que el caso de estudio, prescinde de él: los datos de ámbito de cliente los almacena el navegador en cookies. El servidor no conserva ningún dato entre las solicitudes de un mismo usuario: se dice que no tiene estado ([stateless]). Esto es lo que permite, por ejemplo, ejecutar varios servidores idénticos detrás de un balanceador de carga. La contrapartida: una cookie está bajo el control del usuario, que puede leerla y modificarla. Por lo tanto, solo se almacenan allí datos no sensibles, o datos firmados o cifrados por el servidor, que puede entonces detectar cualquier modificación: es el caso de la cookie [TempData] (ejemplo 20) y del token de autenticación (capítulo 8).

Del lado del servidor, los ámbitos de aplicación y de solicitud corresponden a los tiempos de vida de los servicios de inyección de dependencias (véase el ejemplo 06). [ASP.NET Core] tiene tres:

Registro
Tiempo de vida
Una instancia...
AddSingleton
aplicación
durante toda la vida de la aplicación, compartida por todas las solicitudes
AddScoped
solicitud
por solicitud HTTP, compartida por todos los que la piden durante esa solicitud
AddTransient
ninguno
Por cada inyección: dos solicitudes, dos instancias

6.1. Ejemplo 23: los tres ámbitos

El archivo [Services/CounterService.cs]:

namespace Example23.Services;

// ámbito de APLICACIÓN (AddSingleton): una única instancia, compartida por
// TODAS las solicitudes de TODOS los usuarios
public class CounterService
{
    private int total;

    // varias solicitudes pueden ejecutarse AL MISMO TIEMPO: Interlocked
    // garantiza que dos incrementos simultáneos no se pierdan
    public int Increment() => Interlocked.Increment(ref total);
}
  • Línea 7: el servicio será un singleton (véase [Program.cs]): su campo [total] tiene, por lo tanto, ámbito de aplicación;
  • línea 11: un servidor web procesa varias solicitudes simultáneamente, en varios hilos ([threads]). Si dos solicitudes ejecutan [total++] al mismo tiempo, ambas pueden leer el mismo valor y se pierde un incremento. [Interlocked.Increment] realiza la lectura, la suma y la escritura en una sola operación indivisible. Un servicio singleton debe desconfiar siempre de estos accesos simultáneos.

El archivo [Services/RequestService.cs]:

namespace Example23.Services;

// ámbito de SOLICITUD (AddScoped): una instancia NUEVA por cada solicitud HTTP,
// compartida por todos los que la piden DURANTE esa solicitud
public class RequestService
{
    private static int createdInstances; // static: un contador compartido por todas las instancias

    public int Number { get; } = Interlocked.Increment(ref createdInstances);
}
  • línea 7: un campo declarado [static] pertenece a la clase, no a una instancia; lo comparten todas las instancias. Cuenta el número de instancias creadas;
  • línea 9: a cada instancia se le asigna un número al crearse. El servicio tendrá ámbito de solicitud: el número cambia con cada solicitud.

El archivo [Services/ToolService.cs]:

namespace Example23.Services;

// ámbito TRANSITORIO (AddTransient): una instancia NUEVA en CADA inyección,
// incluso dentro de una misma solicitud
public class ToolService
{
    private static int createdInstances;

    public int Number { get; } = Interlocked.Increment(ref createdInstances);
}

El mismo contador de instancias, para un servicio [transient].

El archivo [Program.cs]:

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

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
// los tres tiempos de vida de un servicio
builder.Services.AddSingleton<CounterService>(); // una instancia para toda la aplicación
builder.Services.AddScoped<RequestService>();    // una instancia por solicitud
builder.Services.AddTransient<ToolService>();    // una instancia por inyección

var app = builder.Build();

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
    RequestPath = "/bootstrap",
});

// ámbito de SOLICITUD: HttpContext.Items nace y muere con la solicitud
app.Use(async (context, next) =>
{
    context.Items["start"] = DateTime.Now.ToString("HH:mm:ss.fff");
    await next(context);
});

app.MapControllers();
app.Run();
  • Líneas 10–12: los tres tiempos de vida;
  • Líneas 23–26: un middleware almacena la hora de recepción de la solicitud en ***[HttpContext.Items], un diccionario que se crea y se destruye junto con la solicitud. Todo lo que procesa la solicitud (filtros, controlador, vista) puede leerlo y escribir en él. Es el equivalente de [res.locals]* en [Express].

El archivo [Controllers/ScopesController.cs]:

using Example23.Services;
using Microsoft.AspNetCore.Mvc;

namespace Example23.Controllers;

public record ScopesModel(int Total, int Instance, int Tool, int MyVisits);

public class ScopesController(CounterService counter, RequestService request, ToolService tool) : Controller
{
    [HttpGet("/")]
    public IActionResult Scopes()
    {
        // ámbito de CLIENTE: un dato guardado por el NAVEGADOR (cookie),
        // reenviado al servidor con cada solicitud
        int.TryParse(Request.Cookies["myVisits"], out var myVisits);
        myVisits++;
        Response.Cookies.Append("myVisits", myVisits.ToString(),
            new CookieOptions { HttpOnly = true, SameSite = SameSiteMode.Lax });
        return View(new ScopesModel(counter.Increment(), request.Number, tool.Number, myVisits));
    }
}
  • línea 8: se inyectan los tres servicios;
  • líneas 15–18: el ámbito de cliente: un contador almacenado en una cookie. [Request.Cookies["myVisits"]] lee la cookie enviada por el navegador ([null] en la primera visita). [int.TryParse] la convierte en entero; si la conversión falla, [myVisits] se establece en 0. La acción lo incrementa y vuelve a establecer la cookie;
  • línea 19: los valores se pasan a la vista.

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

@model ScopesModel
@* @inject: la vista también pide los servicios, durante la MISMA solicitud *@
@inject RequestService RequestOfTheView
@inject ToolService ToolOfTheView
<h1 class="h3">The scopes of data</h1>
<ul>
  <li>application: @Model.Total visit(s) to the site, all browsers combined</li>
  <li>request: instance no. @Model.Instance of RequestService (no. @RequestOfTheView.Number in the view),
    request received at @Context.Items["start"]</li>
  <li>transient: instance no. @Model.Tool of ToolService (no. @ToolOfTheView.Number in the view)</li>
  <li>client: @Model.MyVisits visit(s) from this browser</li>
</ul>
  • líneas 3–4: la directiva [@inject Type Name] solicita un servicio al inyector de dependencias y lo almacena en una propiedad de la vista. La vista se ejecuta durante la misma solicitud que la acción: podremos comparar las instancias recibidas por el controlador y por la vista;
  • Línea 9: el valor de ámbito de solicitud, establecido por el middleware.

Una página, en la URL http://localhost:5000/:

Image

Simulemos dos navegadores con [curl] y dos archivos de cookies, [a.txt] y [b.txt]. El navegador A hace dos solicitudes, luego el navegador B hace una y, por último, A hace una más:

1
2
3
4
curl -c a.txt -b a.txt http://localhost:5000/
curl -c a.txt -b a.txt http://localhost:5000/
curl -c b.txt -b b.txt http://localhost:5000/
curl -c a.txt -b a.txt http://localhost:5000/
browser A:
application: 1 visit(s) to the site, all browsers combined
request: instance no. 1 of RequestService (no. 1 in the view), request received at 12:19:46.574
transient: instance no. 1 of ToolService (no. 2 in the view)
client: 1 visit(s) from this browser

browser A:
application: 2 visit(s) to the site, all browsers combined
request: instance no. 2 of RequestService (no. 2 in the view), request received at 12:19:46.671
transient: instance no. 3 of ToolService (no. 4 in the view)
client: 2 visit(s) from this browser

browser B:
application: 3 visit(s) to the site, all browsers combined
request: instance no. 3 of RequestService (no. 3 in the view), request received at 12:19:46.687
transient: instance no. 5 of ToolService (no. 6 in the view)
client: 1 visit(s) from this browser

browser A:
application: 4 visit(s) to the site, all browsers combined
request: instance no. 4 of RequestService (no. 4 in the view), request received at 12:19:46.696
transient: instance no. 7 of ToolService (no. 8 in the view)
client: 3 visit(s) from this browser

(solo se muestran los elementos de la lista). Observamos que:

  • el contador de aplicación cuenta todas las visitas: 1, 2, 3, 4;
  • cada solicitud tiene su propia instancia de [RequestService]: 1, 2, 3, 4. Durante una solicitud, el controlador y la vista reciben la misma instancia;
  • cada inyección de [ToolService] crea una instancia: el controlador y la vista reciben dos distintas, y cada solicitud crea dos nuevas;
  • el contador de cliente es específico de cada navegador: A tiene 3 visitas, B tiene 1.

La cookie está bajo el control del cliente, que puede enviar el valor que quiera:

curl -i -b "myVisits=41" http://localhost:5000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Set-Cookie: myVisits=42; path=/; samesite=lax; httponly

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
<ul>
  <li>application: 6 visit(s) to the site, all browsers combined</li>
  <li>request: instance no. 6 of RequestService (no. 6 in the view),
    request received at 12:19:47.374</li>
  <li>transient: instance no. 11 of ToolService (no. 12 in the view)</li>
  <li>client: 42 visit(s) from this browser</li>
</ul>

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

Para un contador de visitas, esto es irrelevante. Para datos sensibles (la identidad del usuario, su rol), el servidor debe poder detectar la manipulación: el capítulo 8 muestra cómo.

De estos tiempos de vida se desprende una regla: un servicio no debe depender de un servicio con un tiempo de vida más corto. Un singleton que recibiera un servicio como [Scoped] lo conservaría indefinidamente, mucho más allá de la solicitud para la cual se creó. [ASP.NET Core] verifica el cumplimiento de esta regla al iniciar, en modo de desarrollo, y se niega a arrancar si se infringe. En el caso de estudio:

Ámbito
Datos
¿Dónde?
aplicación
listas de médicos y clientes, diccionarios, CAPTCHA pendientes, contadores de intentos
Servicios singleton ([ListCache], [Translator], [CaptchaService]...)
Solicitud
acceso a la base de datos ([DbContext]), repositorios, capa de negocio, modelo de vista común; usuario conectado
Servicios [Scoped] ([RdvMedecinsDbContext], [BusinessService], [ApplicationModel]...) ; [HttpContext.User], [HttpContext.Items]
cliente
token de autenticación, idioma, mensaje flash
cookies