Impedir o armazenamento em cache no ASP.NET MVC para ações específicas usando um atributo

Eu tenho um aplicativo ASP.NET MVC 3. Este aplicativo solicita registros através do jQuery. O jQuery chama de volta para uma ação do controlador que retorna resultados no formato JSON. Não pude provar isso, mas estou preocupado que meus dados estejam ficando em cache.

Quero apenas que o cache seja aplicado a ações específicas, não a todas as ações.

Existe um atributo que eu possa colocar em uma ação para garantir que os dados não sejam armazenados em cache? Caso contrário, como posso garantir que o navegador obtenha um novo conjunto de registros a cada vez, em vez de um conjunto em cache?

Para garantir que o JQuery não esteja armazenando em cache os resultados, em seus métodos ajax, coloque o seguinte:

$.ajax({
    cache: false
    //rest of your ajax setup
});

Ou para impedir o armazenamento em cache no MVC, criamos nosso próprio atributo, você pode fazer o mesmo. Aqui está o nosso código:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class NoCacheAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext filterContext)
    {
        filterContext.HttpContext.Response.Cache.SetExpires(DateTime.UtcNow.AddDays(-1));
        filterContext.HttpContext.Response.Cache.SetValidUntilExpires(false);
        filterContext.HttpContext.Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
        filterContext.HttpContext.Response.Cache.SetCacheability(HttpCacheability.NoCache);
        filterContext.HttpContext.Response.Cache.SetNoStore();

        base.OnResultExecuting(filterContext);
    }
}

Em seguida, basta decorar seu controlador com [NoCache]. OU para fazer isso por tudo, você pode simplesmente colocar o atributo na classe da classe base da qual você herda seus controladores (se você tiver um) como nós temos aqui:

[NoCache]
public class ControllerBase : Controller, IControllerBase

Você também pode decorar algumas das ações com esse atributo se precisar que elas não sejam armazenáveis ​​em cache, em vez de decorar todo o controlador.

Se a sua classe ou ação não teve NoCachequando foi renderizada no seu navegador e você deseja verificar se está funcionando, lembre-se de que, após compilar as alterações, é necessário fazer uma "atualização definitiva" (Ctrl + F5) no seu navegador. Até você fazer isso, seu navegador manterá a versão antiga em cache e não a atualizará com uma "atualização normal" (F5).

Você pode usar o atributo de cache interno para impedir o armazenamento em cache.

Para o .net Framework: [OutputCache(NoStore = true, Duration = 0)]

Para .net Core: [ResponseCache(NoStore = true, Duration = 0)]

Esteja ciente de que é impossível forçar o navegador a desativar o cache. O melhor que você pode fazer é fornecer sugestões que a maioria dos navegadores respeitará, geralmente na forma de cabeçalhos ou metatags. Este atributo decorador irá desativar o cache do servidor e também adicionar este cabeçalho: Cache-Control: public, no-store, max-age=0. Não adiciona meta tags. Se desejado, esses podem ser adicionados manualmente na exibição.

Além disso, o JQuery e outras estruturas de clientes tentarão induzir o navegador a não usar sua versão em cache de um recurso adicionando itens ao URL, como um carimbo de data / hora ou GUID. Isso é eficaz para fazer o navegador solicitar o recurso novamente, mas na verdade não impede o armazenamento em cache.

Em uma nota final. Você deve estar ciente de que os recursos também podem ser armazenados em cache entre o servidor e o cliente. Os ISP, proxies e outros dispositivos de rede também armazenam em cache recursos e geralmente usam regras internas sem examinar o recurso real. Não há muito que você possa fazer sobre isso. A boa notícia é que eles geralmente armazenam em cache por períodos mais curtos, como segundos ou minutos.

Tudo o que você precisa é:

[OutputCache(Duration=0)]
public JsonResult MyAction(

ou, se você deseja desativá-lo para um controlador inteiro:

[OutputCache(Duration=0)]
public class MyController

Apesar do debate nos comentários aqui, isso é suficiente para desativar o cache do navegador - isso faz com que o ASP.Net emita cabeçalhos de resposta que informam ao navegador que o documento expira imediatamente:

Na ação do controlador, adicione ao cabeçalho as seguintes linhas

    public ActionResult Create(string PositionID)
    {
        Response.AppendHeader("Cache-Control", "no-cache, no-store, must-revalidate"); // HTTP 1.1.
        Response.AppendHeader("Pragma", "no-cache"); // HTTP 1.0.
        Response.AppendHeader("Expires", "0"); // Proxies.

Aqui está o NoCacheatributo proposto por mattytommo, simplificado usando as informações da resposta de Chris Moschini:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class NoCacheAttribute : OutputCacheAttribute
{
    public NoCacheAttribute()
    {
        this.Duration = 0;
    }
}

Para MVC6 ( DNX ), não háSystem.Web.OutputCacheAttribute

Nota: quando você define o NoStoreparâmetro Duration, não é considerado. É possível definir uma duração inicial para o primeiro registro e substituí-la por atributos personalizados.

Mas nos temos Microsoft.AspNet.Mvc.Filters.ResponseCacheFilter

 public void ConfigureServices(IServiceCollection services)
        ...
        services.AddMvc(config=>
        {
            config.Filters.Add(
                 new ResponseCacheFilter(
                    new CacheProfile() { 
                      NoStore=true
                     }));
        }
        ...
       )

É possível substituir o filtro inicial por um atributo personalizado

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
    public sealed class NoCacheAttribute : ActionFilterAttribute
    {
        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            var filter=filterContext.Filters.Where(t => t.GetType() == typeof(ResponseCacheFilter)).FirstOrDefault();
            if (filter != null)
            {
                ResponseCacheFilter f = (ResponseCacheFilter)filter;
                f.NoStore = true;
                //f.Duration = 0;
            }

            base.OnResultExecuting(filterContext);
        }
    }

Aqui está um caso de uso

    [NoCache]
    [HttpGet]
    public JsonResult Get()
    {            
        return Json(new DateTime());
    }

Cache de saída no MVC

[OutputCache (NoStore = true, Duração = 0, Localização = "Nenhuma", VaryByParam = "*")]

OU
[OutputCache (NoStore = true, Duração = 0, VaryByParam = "None")]

O valor correto do atributo para o Asp.Net MVC Core para impedir o cache do navegador (incluindo o Internet Explorer 11 ) é:

[ResponseCache(Location = ResponseCacheLocation.None, NoStore = true)]

conforme descrito na documentação da Microsoft:

Cache de resposta no ASP.NET Core - NoStore e Location.None

Soluções ASP.NET MVC 5:

1. Caching código de prevenção em um local central: o App_Start/FilterConfig.cs's RegisterGlobalFiltersmétodo:

    public class FilterConfig
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            // ...
            filters.Add(new OutputCacheAttribute
            {
                NoStore = true,
                Duration = 0,
                VaryByParam = "*",
                Location = System.Web.UI.OutputCacheLocation.None
            });
        }
    }

2. Depois de implementá-lo, entendo que você pode substituir o filtro global aplicando uma OutputCachediretiva Controllerou Viewnível diferente. Para o controlador regular, é

[OutputCache(NoStore = true, Duration = 0, Location=System.Web.UI.ResponseCacheLocation.None, VaryByParam = "*")]

ou se é ApiControllerque seria

[System.Web.Mvc.OutputCache(NoStore = true, Duration = 0, Location = System.Web.UI.OutputCacheLocation.None, VaryByParam = "*")]