Como criar um filtro de ação personalizado no ASP.NET MVC

No ASP.NET MVC, os filtros são usados para injetar lógica em diferentes níveis de processamento de solicitações e nos permitem compartilhar lógicas entre os controladores. Por exemplo, digamos que queremos executar uma lógica de segurança ou uma lógica de log no controlador. Para fazer isso, escreveremos um filtro contendo essas lógicas e as habilitaremos em todos os controladores. Quando habilitamos um filtro em todos os controladores ou ações, o filtro habilita a próxima solicitação HTTP.

Vamos considerar um cenário de Log: para cada solicitação recebida, precisamos registrar alguns dados nos arquivos com base em alguma lógica. Se não criarmos essa lógica dentro de um filtro personalizado, teremos que escrever lógica para a ação de cada controlador. Este mecanismo levará a dois problemas:

1. duplicação de código; e
2. violação dos Princípios de Responsabilidade Única; As ações agora executarão tarefas adicionais de registro em log.

Podemos mitigar os problemas acima colocando a lógica de log dentro de um filtro de ação personalizado e aplicando o filtro em todos os níveis dos controladores.

Você já se deparou com o código-fonte como mostrado na imagem abaixo? [Authorize] é um filtro de autorização e é executado antes de qualquer solicitação HTPP ou execução do método de ação.  O filtro Authorize faz parte do MVC, mas, se necessário, também podemos criar um filtro personalizado.

No ASP.NET MVC, existem quatro tipos de filtros:

1. Filtro de autenticação
2. Authorization Filter
3. Filtro de ação
4. Result Filter
5. Filtro de exceção

A sequência de execução de vários filtros é a seguinte:

• O filtro de autenticação é executado antes de qualquer outro filtro ou método de ação
• O filtro de autorização é executado após o filtro de autenticação e antes de qualquer outro filtro ou método de ação
• O filtro Ação é executado antes e depois de qualquer método de ação
• O filtro Resultado é executado antes e depois da execução de qualquer resultado de ação
• O filtro de exceção será executado somente se métodos de ação, filtros ou resultados de ação gerarem uma exceção

Em um diagrama, podemos descrever a sequência de execução do filtro, conforme mostrado abaixo:

Cada filtro tem seus próprios propósitos, no entanto, na maioria das vezes você se verá escrevendo um Filtro de Ação Personalizado. Eles são executados antes e depois da execução de uma ação.

Custom Action Filter

Escrevemos filtros de ação personalizados por vários motivos. Podemos ter um filtro de ação personalizado para registro em log ou para salvar dados em um banco de dados antes da execução de qualquer ação. Também poderíamos ter um para buscar dados do banco de dados e defini-los como os valores globais do aplicativo. Podemos criar filtros de ação personalizados por vários motivos, incluindo, mas não se limitando a:

• Criando uma autorização privilegiada
• Registrando a solicitação do usuário
• Pré-processamento de upload de imagem
• Buscando dados para exibir no menu de layout
• Localização do aplicativo
• Lendo informações do agente do usuário do navegador para executar uma tarefa específica
• Caching, etc.

Para criar um filtro de ação personalizado, precisamos executar as seguintes tarefas:

1. Create a class
2. Inherit it from ActionFilterAttribute class
3. Substitua pelo menos um dos seguintes métodos:

• OnActionExecuting: esse método é chamado antes que uma ação do controlador seja executada.
• OnActionExecuted: esse método é chamado depois que uma ação do controlador é executada.
• OnResultExecuting: esse método é chamado antes que um resultado de ação do controlador seja executado.
• OnResultExecuted: esse método é chamado depois que um resultado de ação do controlador é executado.

Vamos criar um filtro de ação personalizado que executará duas tarefas, da maneira mais simplista. É claro que você pode escrever um código mais sofisticado dentro do filtro de ação personalizado, mas vamos criar um filtro personalizado com o nome MyFirstCustomFilter, que executará as duas tarefas a seguir:

1. Defina algum valor de dados no ViewBag global.
2. Registre a solicitação de entrada no método de ação do controlador.

O filtro pode ser criado conforme mostrado na listagem abaixo:

using System;
using System.Diagnostics;
using System.Web.Mvc;

namespace WebApplication1
{
    public class MyFirstCustomFilter : ActionFilterAttribute
    {
        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            //You may fetch data from database here 
            filterContext.Controller.ViewBag.GreetMesssage = "Hello Foo";
            base.OnResultExecuting(filterContext);
        }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            var controllerName = filterContext.RouteData.Values["controller"];
            var actionName = filterContext.RouteData.Values["action"];
            var message = String.Format("{0} controller:{1} action:{2}", "onactionexecuting", controllerName, actionName);
            Debug.WriteLine(message, "Action Filter Log");
            base.OnActionExecuting(filterContext);
        }
    }
}

Na listagem acima, estamos simplesmente definindo a propriedade ViewBag para os controladores que estão sendo executados. A propriedade ViewBag será definida antes que um resultado de ação do controlador seja executado, pois estamos substituindo o método OnResultExecuting . Além disso, estamos substituindo OnActionExecuting para registrar as informações sobre o método de ação do controlador.

Então, agora criamos o filtro de ação personalizado. Agora podemos aplicar isso em três níveis possíveis:

• Como um filtro global
• No nível do controlador
• A nível de ação

Aplicando como um filtro global

Podemos aplicar um filtro personalizado em nível global adicionando um filtro ao filtro global em App_Start\FilterConfig. Depois de adicionado no nível global, o filtro estaria disponível para todos os controladores no aplicativo MVC.

public class FilterConfig
{
  public static void RegisterGlobalFilters(GlobalFilterCollection filters)
  {
      filters.Add(new HandleErrorAttribute());
      filters.Add(new MyFirstCustomFilter());
   }
}

Filtrar em um nível de controlador

Para aplicar um filtro no nível do controlador, podemos aplicá-lo como um atributo a um controlador específico. Quando aplicada como nível de controlador, a ação estaria disponível para todas as ações do controlador específico. Podemos aplicar MyFirstCustomFilter ao HomeController, conforme mostrado na listagem abaixo:

[MyFirstCustomFilter]
  public class HomeController : Controller
 {
     public ActionResult Index()
     {
        return View();
    }
}

Filtrar em um nível de ação

Por fim, para aplicar um filtro em uma ação específica, podemos aplicá-lo como um atributo da Ação, conforme mostrado na listagem abaixo:

[MyFirstCustomFilter]
public ActionResult Contact()
{
    ViewBag.Message = "Your contact page.";
    return View();
}

E isso é tudo para filtros de ação personalizados! Espero que você ache este post útil e obrigado por ler. Tem algo a acrescentar? Sinta-se à vontade para deixar um comentário!