Impedire la memorizzazione nella cache in ASP.NET MVC per azioni specifiche utilizzando un attributo

Ho un'applicazione ASP.NET MVC 3. Questa applicazione richiede record tramite jQuery. jQuery richiama un'azione del controller che restituisce risultati in formato JSON. Non sono stato in grado di dimostrarlo, ma sono preoccupato che i miei dati possano essere memorizzati nella cache.

Voglio solo che la memorizzazione nella cache venga applicata ad azioni specifiche, non per tutte le azioni.

Esiste un attributo che posso inserire in un'azione per garantire che i dati non vengano memorizzati nella cache? In caso contrario, come posso garantire che il browser ottenga ogni volta un nuovo set di record anziché un set memorizzato nella cache?

Per assicurarsi che JQuery non memorizzi nella cache i risultati, nei metodi ajax, inserisci quanto segue:

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

O per evitare la memorizzazione nella cache in MVC, abbiamo creato il nostro attributo, potresti fare lo stesso. Ecco il nostro codice:

[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);
    }
}

Quindi decora il controller con [NoCache]. O per farlo per tutto ciò che potresti semplicemente mettere l'attributo sulla classe della classe base da cui erediti i tuoi controller (se ne hai uno) come abbiamo qui:

[NoCache]
public class ControllerBase : Controller, IControllerBase

Puoi anche decorare alcune delle azioni con questo attributo se hai bisogno che non siano memorizzabili nella cache, invece di decorare l'intero controller.

Se la tua classe o azione non ha avuto NoCachequando è stato eseguito il rendering nel tuo browser e desideri verificarne il funzionamento, ricorda che dopo aver compilato le modifiche devi eseguire un "aggiornamento rapido" (Ctrl + F5) nel tuo browser. Fino a quando non lo fai, il tuo browser manterrà la vecchia versione memorizzata nella cache e non la aggiornerà con un "aggiornamento normale" (F5).

È possibile utilizzare l'attributo cache incorporato per impedire la memorizzazione nella cache.

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

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

Tenere presente che è impossibile forzare il browser a disabilitare la memorizzazione nella cache. Il meglio che puoi fare è fornire suggerimenti che la maggior parte dei browser rispetterà, di solito sotto forma di intestazioni o meta tag. Questo attributo decoratore disabiliterà la cache del server e anche aggiungere questa intestazione: Cache-Control: public, no-store, max-age=0. Non aggiunge meta tag. Se lo si desidera, è possibile aggiungerli manualmente nella vista.

Inoltre, JQuery e altri framework client tenteranno di indurre il browser a non utilizzare la versione cache di una risorsa aggiungendo elementi all'URL, come un timestamp o un GUID. Questo è efficace nel fare nuovamente chiedere al browser la risorsa, ma in realtà non impedisce la memorizzazione nella cache.

Un'ultima nota. È necessario tenere presente che le risorse possono anche essere memorizzate nella cache tra il server e il client. Anche gli ISP, i proxy e altri dispositivi di rete memorizzano nella cache le risorse e spesso usano regole interne senza esaminare la risorsa effettiva. Non c'è molto che puoi fare al riguardo. La buona notizia è che in genere vengono memorizzati nella cache per intervalli di tempo più brevi, come secondi o minuti.

Tutto ciò che serve è:

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

oppure, se si desidera disabilitarlo per un intero controller:

[OutputCache(Duration=0)]
public class MyController

Nonostante il dibattito nei commenti qui, questo è sufficiente per disabilitare la memorizzazione nella cache del browser - questo fa sì che ASP.Net emetta intestazioni di risposta che indicano al browser che il documento scade immediatamente:

Nell'azione del controller aggiungere all'intestazione le seguenti righe

    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.

Ecco l' NoCacheattributo proposto da mattytommo, semplificato utilizzando le informazioni dalla risposta di Chris Moschini:

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

Per MVC6 ( DNX ), non esisteSystem.Web.OutputCacheAttribute

Nota: quando si imposta il NoStoreparametro Durata non viene considerato. È possibile impostare una durata iniziale per la prima registrazione e sovrascriverla con attributi personalizzati.

Ma noi abbiamo Microsoft.AspNet.Mvc.Filters.ResponseCacheFilter

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

È possibile sovrascrivere il filtro iniziale con un attributo personalizzato

    [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);
        }
    }

Ecco un caso d'uso

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

Memorizzazione nella cache di output in MVC

[OutputCache (NoStore = true, Duration = 0, Location = "None", VaryByParam = "*")]

O
[OutputCache (NoStore = true, Duration = 0, VaryByParam = "None")]

Il valore dell'attributo corretto per Asp.Net MVC Core per impedire la memorizzazione nella cache del browser (incluso Internet Explorer 11 ) è:

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

come descritto nella documentazione Microsoft:

Memorizzazione nella cache di risposta in ASP.NET Core - NoStore e Location.None

Soluzioni ASP.NET MVC 5:

1. La memorizzazione nella cache il codice di prevenzione in una posizione centrale: la App_Start/FilterConfig.cs's RegisterGlobalFiltersmetodo:

    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. Una volta che hai messo in atto ciò, la mia comprensione è che puoi scavalcare il filtro globale applicando una OutputCachedirettiva diversa a livello Controllero View. Per il normale controller è

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

o se fosse un ApiControllersarebbe

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