Skip to content

7. O ciclo de vida de uma requisição

Entre a chegada de uma requisição e a execução da action, o [ASP.NET Core] envolve vários tipos de objetos, cada um com um papel específico. Já encontramos alguns deles: os middlewares ([UseStaticFiles], [UseRequestLocalization], o middleware do Exemplo 23) e o binding de modelo ([IModelBinder], Exemplo 12). O componente MVC acrescenta filtros que são executados em torno da action. O estudo de caso usa cada um deles:

Image

Objeto
Papel
No estudo de caso
middleware
Prepara a requisição; ainda não conhece a action
arquivos estáticos, idioma, autenticação (leitura do token), páginas de erro
filtro de autorização
Permite ou nega o acesso à action
[[Authorize]], [[Authorize(Roles = ...)]]
Binding de modelo
Converte e valida os parâmetros
formulários, [ModelState]
filtro de ação
Código antes e depois da action
(não utilizado: os serviços e a classe pai das views são suficientes)
filtro de exceção
Converte uma exceção em uma resposta
Sessão expirada: redireciona para /login

7.1. Exemplo 24: as etapas do processamento de uma requisição

O Exemplo 24 tem uma action que calcula o quadrado de um número e um objeto de cada tipo. Cada um escreve uma linha no console, para que possamos ver a ordem em que são executados.

24-lifecycle/
├── Controllers/
│   ├── CalcController.cs
│   └── ErrorController.cs
├── Filters/
│   ├── BlockAttribute.cs
│   ├── ErrorPageFilter.cs
│   ├── IntegerBinder.cs
│   ├── LoggerMiddleware.cs
│   └── TimingAttribute.cs
├── Views/
│   ├── Calc/
│   │   └── Result.cshtml
│   ├── Shared/
│   │   ├── _Layout.cshtml
│   │   └── Error.cshtml
│   └── _ViewStart.cshtml
├── appsettings.json
├── Example24.csproj
└── Program.cs

O arquivo [Filters/LoggerMiddleware.cs]:

namespace Example24.Filters;

// um middleware escrito como classe: ele recebe o restante do pipeline
// (next) em seu construtor e trata cada requisição em InvokeAsync
public class LoggerMiddleware(RequestDelegate next)
{
    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine();
        Console.WriteLine($"--- {context.Request.Method} {context.Request.Path}{context.Request.QueryString}");
        Console.WriteLine("1. middleware (before)");
        await next(context); // todo o restante: roteamento, filtros, action, view
        Console.WriteLine($"8. middleware (after: code {context.Response.StatusCode})");
    }
}
  • Linha 5: um middleware pode ser uma classe. Seu construtor recebe um [RequestDelegate]: o restante do pipeline (os middlewares seguintes, seguidos pelo MVC);
  • linha 7: o método [InvokeAsync] é chamado a cada requisição;
  • linha 12: o middleware chama o restante do pipeline e espera que ele termine. Se não o chamasse, a requisição pararia ali (ele teria então de gerar a resposta por conta própria). O código colocado antes dessa chamada é executado na ida da requisição, e o código colocado depois dela é executado na volta: o middleware “envolve” todo o resto e enxerga o código de status final da resposta.

O arquivo [Filters/BlockAttribute.cs]:

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Example24.Filters;

// um filtro de AUTORIZAÇÃO: ele decide se a action pode ser executada.
// É também um atributo: é aplicado a um controller ou a uma action.
public class BlockAttribute : Attribute, IAuthorizationFilter
{
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        // o filtro conhece a action alvo, ao contrário do middleware
        var action = (ControllerActionDescriptor)context.ActionDescriptor;
        Console.WriteLine($"2. authorization filter (targeted action: {action.ActionName})");
        if (context.HttpContext.Request.Query.ContainsKey("block"))
        {
            // definir Result interrompe o restante: sem binding, sem action
            context.Result = new StatusCodeResult(StatusCodes.Status403Forbidden);
        }
    }
}
  • linha 9: um filtro de autorização implementa [IAuthorizationFilter]. A classe também deriva de [Attribute]: ela pode ser aplicada, entre colchetes, a um controller ou a uma action;
  • linhas 14–15: diferentemente de um middleware, o filtro conhece a action de destino ([ActionDescriptor]). É isso que permite que o atributo [[Authorize(Roles = "ADMIN")]] (veja o próximo capítulo) proteja apenas algumas actions;
  • linhas 16–19: um filtro rejeita a requisição definindo [context.Result]: a sequência (binding, action) não é executada, e esse resultado se torna a resposta. Aqui, uma resposta 403 (acesso negado), sem conteúdo.

O arquivo [Filters/IntegerBinder.cs]:

using Microsoft.AspNetCore.Mvc.ModelBinding;

namespace Example24.Filters;

// o model binding de um parâmetro inteiro (veja o exemplo 12)
public class IntegerBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext context)
    {
        var value = context.ValueProvider.GetValue(context.ModelName).FirstValue;
        Console.WriteLine($"3. model binding (received value: \"{value}\")");
        if (int.TryParse(value, out var integer))
        {
            context.Result = ModelBindingResult.Success(integer);
        }
        else
        {
            context.ModelState.AddModelError(context.ModelName, $"\"{value}\" is not an integer.");
        }
        return Task.CompletedTask;
    }
}

Um binding de modelo personalizado, como os do Exemplo 12. Um valor inválido não interrompe nada: o erro é registrado em [ModelState], e a action determina o resultado (linha 18).

O arquivo [Filters/TimingAttribute.cs]:

using System.Diagnostics;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Example24.Filters;

// um filtro de ACTION: código antes e depois da action.
// ActionFilterAttribute: uma classe do framework, cujos métodos úteis sobrescrevemos
public class TimingAttribute : ActionFilterAttribute
{
    private const string Key = "timing";

    public override void OnActionExecuting(ActionExecutingContext context)
    {
        // os parâmetros da action já estão vinculados: o filtro pode lê-los
        Console.WriteLine($"4. action filter (before; parameters: {string.Join(", ", context.ActionArguments.Values)})");
        context.HttpContext.Items[Key] = Stopwatch.StartNew();
    }

    public override void OnActionExecuted(ActionExecutedContext context)
    {
        var timer = (Stopwatch)context.HttpContext.Items[Key]!;
        // context.Exception: a exceção eventualmente lançada pela action
        var outcome = context.Exception is null ? "" : $", exception {context.Exception.GetType().Name}";
        Console.WriteLine($"6. action filter (after, {timer.ElapsedMilliseconds} ms{outcome})");
    }
}
  • linha 8: um filtro de ação. [ActionFilterAttribute] é uma classe do framework que já implementa as interfaces necessárias: sobrescrevemos ([override]) os métodos pertinentes;
  • Linhas 12–16: [OnActionExecuting] é executado antes da action. O binding do modelo já ocorreu: os parâmetros da action estão disponíveis ([ActionArguments]). Um cronômetro é iniciado ([Stopwatch]) e armazenado em [HttpContext.Items] (escopo de requisição; veja o Capítulo 6);
  • linhas 19–24: [OnActionExecuted] é executado depois da action. Se a action lançou uma exceção, ela está disponível em [context.Exception]. Um filtro de ação também pode substituir o resultado da action ([context.Result]).

O arquivo [Filters/ErrorPageFilter.cs]:

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ViewFeatures;

namespace Example24.Filters;

// um filtro de EXCEÇÃO: ele transforma uma exceção em uma resposta
public class ErrorPageFilter(IModelMetadataProvider metadata) : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        Console.WriteLine($"x. exception filter ({context.Exception.GetType().Name}: {context.Exception.Message})");
        // em vez da página de erro padrão, nossa view Error, com o código 500
        context.Result = new ViewResult
        {
            ViewName = "Error",
            StatusCode = StatusCodes.Status500InternalServerError,
            ViewData = new ViewDataDictionary(metadata, context.ModelState) { Model = 500 },
        };
        context.ExceptionHandled = true; // a exceção está tratada: ela não segue adiante
    }
}
  • Linha 9: um filtro de exceção implementa [IExceptionFilter]. Ele recebe as exceções lançadas pelo binding do modelo, pelos filtros de ação e pela action. Ele é um serviço: recebe por injeção o objeto [IModelMetadataProvider], necessário para construir o dicionário [ViewData] de uma view;
  • linhas 15–20: em vez da página de erro padrão, o filtro gera uma página HTML: a view [Error], com código de status 500. É o que faz o método [View] de um controller, escrito aqui manualmente;
  • Linha 21: a exceção é marcada como tratada; ela não se propaga mais acima na cadeia.

O arquivo [Program.cs]:

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

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews(options =>
{
    // um filtro GLOBAL: aplica-se a todas as actions da aplicação
    options.Filters.Add<ErrorPageFilter>();
});
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));

var app = builder.Build();

// os middlewares são executados na ordem em que são adicionados
app.UseMiddleware<LoggerMiddleware>();
// uma resposta de erro SEM conteúdo (400, 403, 404...): a requisição é
// reexecutada com o endereço /error/{code}, que constrói uma página
app.UseStatusCodePagesWithReExecute("/error/{0}");
app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
    RequestPath = "/bootstrap",
});

app.MapControllers();
app.Run();
  • linha 10: um filtro global é aplicado a todas as actions da aplicação. Ele é adicionado às opções do MVC;
  • linha 17: um middleware baseado em classe é adicionado por meio de [UseMiddleware]. Os middlewares são executados na ordem em que são adicionados: este é o primeiro, portanto processa todas as requisições;
  • linha 20: um middleware do framework. Quando uma resposta de erro (códigos 400–599) não tem conteúdo, ele reexecuta a requisição usando o endereço [/error/{code}] (em que [{0}] é substituído pelo código) e retorna a página resultante mantendo o código de erro. É assim que as respostas 403 do filtro de autorização, as respostas 400 da action e as respostas 404 do roteamento se tornam páginas HTML.

O arquivo [Controllers/CalcController.cs]:

using Example24.Filters;
using Microsoft.AspNetCore.Mvc;

namespace Example24.Controllers;

// dois filtros definidos no controller: aplicam-se a todas as suas actions
[Block]
[Timing]
public class CalcController : Controller
{
    [HttpGet("square/{n}")]
    public IActionResult Square([ModelBinder(typeof(IntegerBinder))] int n)
    {
        Console.WriteLine($"5. action Square({n}); valid model: {ModelState.IsValid}");
        if (!ModelState.IsValid)
        {
            return BadRequest(); // um 400 sem conteúdo: veja UseStatusCodePagesWithReExecute
        }
        if (n == 13)
        {
            throw new InvalidOperationException("13 brings bad luck"); // um erro "inesperado"
        }
        return View("Result", n * n);
    }
}
  • linhas 7–8: dois filtros aplicados ao controller; eles se aplicam a todas as suas actions (também podem ser aplicados a uma única action);
  • linha 12: o binding de parâmetro personalizado;
  • linhas 15–17: um parâmetro inválido: uma resposta 400 sem conteúdo;
  • linhas 19–21: um erro “inesperado”, para ver o filtro de exceção em ação.

O arquivo [Controllers/ErrorController.cs]:

using Microsoft.AspNetCore.Mvc;

namespace Example24.Controllers;

public class ErrorController : Controller
{
    // [Route] sem método HTTP: a requisição reexecutada mantém seu método original
    [Route("error/{code:int}")]
    public IActionResult Display(int code)
    {
        Console.WriteLine($"7. error page {code} (re-executed request)");
        Response.StatusCode = code; // a página mantém o código de erro
        return View("Error", code);
    }
}
  • linha 8: a action da página de erro. [[Route]], sem método HTTP, aceita todos os métodos: uma requisição POST reexecutada continua sendo uma requisição POST;
  • Linha 12: a página mantém o código de erro original.

O arquivo [Views/Shared/Error.cshtml]:

@* a página de erro; seu modelo: o código de erro *@
@model int
@{
    var message = Model switch
    {
        400 => "Bad request.",
        403 => "Access denied.",
        404 => "Page not found.",
        _ => "Internal server error.",
    };
}
<div class="alert alert-danger">
  <h1 class="h4">Error @Model</h1>
  <p class="mb-0">@message</p>
</div>
  • Linhas 4–10: uma expressão switch [C#]: ela retorna o valor do primeiro ramo cujo padrão corresponde ao modelo. [_] corresponde a todo o resto. A view está em [Views/Shared]: ela é encontrada independentemente do controller ([CalcController] para o filtro de exceção, [ErrorController] nos demais casos).

Cinco requisições: um cálculo normal (http://localhost:5000/square/7), um parâmetro inválido ([/square/abc]), uma requisição bloqueada pelo filtro de autorização ([/square/7?block=1]), um erro inesperado ([/square/13]) e um endereço desconhecido ([/unknown]). O console do servidor:

--- GET /square/7
1. middleware (before)
2. authorization filter (targeted action: Square)
3. model binding (received value: "7")
4. action filter (before; parameters: 7)
5. action Square(7); valid model: True
6. action filter (after, 0 ms)
8. middleware (after: code 200)

--- GET /square/abc
1. middleware (before)
2. authorization filter (targeted action: Square)
3. model binding (received value: "abc")
4. action filter (before; parameters: )
5. action Square(0); valid model: False
6. action filter (after, 0 ms)
7. error page 400 (re-executed request)
8. middleware (after: code 400)

--- GET /square/7?block=1
1. middleware (before)
2. authorization filter (targeted action: Square)
7. error page 403 (re-executed request)
8. middleware (after: code 403)

--- GET /square/13
1. middleware (before)
2. authorization filter (targeted action: Square)
3. model binding (received value: "13")
4. action filter (before; parameters: 13)
5. action Square(13); valid model: True
6. action filter (after, 0 ms, exception InvalidOperationException)
x. exception filter (InvalidOperationException: 13 brings bad luck)
8. middleware (after: code 500)

--- GET /unknown
1. middleware (before)
7. error page 404 (re-executed request)
8. middleware (after: code 404)

Este log mostra:

  • a ordem das etapas: middleware, filtro de autorização, binding do modelo, filtro de ação (antes), action, filtro de ação (depois) e, por fim, o middleware novamente, que enxerga o código de resposta final;
  • o filtro de autorização que rejeita a requisição ignora o restante do MVC (sem binding, sem action);
  • um parâmetro inválido não impede a execução da action: a própria action decide, com base em [ModelState] (veja o exemplo 09);
  • uma exceção da action é tratada pelo filtro de exceção, que gera a resposta;
  • uma resposta de erro vazia (400, 403, 404) é convertida em uma página pela reexecução da requisição (etapa 7). Para um endereço desconhecido, o MVC nem sequer entra em cena: nenhuma rota corresponde.

As páginas resultantes:

Image

Image

Image

Image

Vamos verificar se o código de erro é preservado:

curl -i http://localhost:5000/square/7?block=1
HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Lifecycle</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
  <div class="container py-3">
    <div class="alert alert-danger">
  <h1 class="h4">Error 403</h1>
  <p class="mb-0">Access denied.</p>
</div>

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

O estudo de caso combina esses mecanismos: [UseStatusCodePagesWithReExecute("/error/{0}")] e um controller ([ErrorController]) para as páginas 400, 403 e 404; o middleware [UseExceptionHandler("/error/500")], que reexecuta de modo semelhante qualquer requisição que termine com uma exceção não tratada; e um filtro de exceção ([Web/HtmlExceptionFilter.cs]) para um caso específico: uma sessão expirada não exibe uma página de erro, mas redireciona para a página de login.