Como você aplica filtros em pipelines em C#? Pode dar…

Os filtros nos pipelines C# são utilizados para interceptar e intervir em diferentes etapas do processamento de uma solicitação ou execução de uma tarefa. Em aplicações web ASP.NET Core, eles permitem adicionar lógica antes, depois ou durante a execução dos métodos de ação dos controladores, bem como em outros níveis de processamento de solicitações.

Exemplos de uso de filtros no ASP.NET Core:

Filtros de Autenticação e Autorização: Determinam se um usuário está autorizado a realizar uma ação específica.

// Exemplo de atributo Authorize
[Authorize]
public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

Filtros de recursos: São executados primeiro após os filtros de autorização. Podem realizar caching ou interromper o pipeline.

// Exemplo de filtro de recursos para caching
public class CacheResourceFilter : IResourceFilter
{
    public void OnResourceExecuting(ResourceExecutingContext context)
    {
        // Lógica antes de executar a ação
    }

    public void OnResourceExecuted(ResourceExecutedContext context)
    {
        // Lógica após executar a ação, mas antes de escrever a resposta
    }
}

Filtros de ação: São executados antes e depois do método de ação do controlador. São úteis para validar dados, fazer logging ou modificar parâmetros e resultados.

// Exemplo de filtro de ação para logging
public class LogActionFilter : IActionFilter
{
    public void OnActionExecuting(ActionExecutingContext context)
    {
        // Lógica antes de executar a ação
        Console.WriteLine($"Executando ação: {context.ActionDescriptor.DisplayName}");
    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        // Lógica após executar a ação
        Console.WriteLine($"Ação executada: {context.ActionDescriptor.DisplayName}");
    }
}

// Aplicar filtro de ação a um método
[LogActionFilter]
public IActionResult About()
{
    return View();
}

Filtros de exceções: Gerenciam exceções não tratadas que ocorrem durante a execução do método de ação ou outros filtros.

// Exemplo de filtro de exceção para tratamento de erros
public class CustomExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        // Lógica de tratamento de exceção
        context.Result = new ContentResult()
        {
            Content = "Ocorreu um erro.",
            StatusCode = 500
        };
        context.ExceptionHandled = true; // Indica que a exceção foi tratada
    }
}

// Aplicar filtro de exceção ao controlador
[CustomExceptionFilter]
public class ErrorController : Controller
{
    public IActionResult Index()
    {
        throw new Exception("Algo deu errado!");
    }
}

Filtros de resultados: São executados antes e depois da execução do método de resultado (por exemplo, antes ou depois de ViewResult, JsonResult, etc.).

// Exemplo de filtro de resultado para modificar o resultado
public class CustomResultFilter : IResultFilter
{
    public void OnResultExecuting(ResultExecutingContext context)
    {
        // Lógica antes de executar o método de resultado
        Console.WriteLine($"Executando tipo de resultado: {context.Result.GetType().Name}");
    }

    public void OnResultExecuted(ResultExecutedContext context)
    {
        // Lógica após executar o método de resultado
        Console.WriteLine($"Tipo de resultado executado: {context.Result.GetType().Name}");
    }
}

Os filtros podem ser aplicados globalmente (para todas as solicitações), a nível de controlador ou a nível de método de ação específico. A ordem de execução no pipeline é determinada pelo seu tipo.

Como você aplica filtros em pipelines em C#? Pode dar exemplos de seu uso?