Bundle ASP.NET – Bundle non aggiornato dopo che il file incluso è cambiato (restituisce 304 non modificato)

Sto provando il bundle ASP.NET con l’applicazione ASP.NET MVC 4. La situazione è che voglio creare un servizio in stile CDN, che contiene file JS e CSS a cui è ansible accedere da altri siti con questo indirizzo di tipo: http://www.mycdn.com/scripts/plugin/js , che raggruppa e minimizza tutti i file .js inclusi.

La mia configurazione di bundle per un file è simile alla seguente:

bundles.Add(new ScriptBundle("~/Scripts/plugin/pluginjs").Include("~/Scripts/plugin/jquery.plugin.js")); 

Tuttavia, quando eseguo questa operazione, i pacchetti non vengono aggiornati anche dopo aver modificato i file js originali. Continuo a ricevere 304 Not Modified, quando aggiorno il browser e il contenuto del file minified non viene aggiornato. Come posso aggiornare i bundle, perché è inutile avere pacchetti con vecchi contenuti? Ho provato in tutti i modi, ma non sono riuscito a trovare una soluzione.

Grazie in anticipo!

Ho appena avuto lo stesso identico problema. Ho una cartella con 2 file CSS:

  • ~ / Content / main.css
  • ~ / Content / main.min.css (preesistente dal mio precedente processo di minimizzazione manuale)

Il mio codice di raggruppamento è questo:

 bundles.Add(new StyleBundle("~/css/main").Include("~/content/main.css")); 

Non importa quanto ho cambiato il mio main.css l’output era lo stesso url con lo stesso contenuto:

  

L’unico modo per aggiornare il pacchetto era ribuild la mia soluzione, ovviamente non l’approccio migliore.

Tuttavia, non appena ho eliminato main.min.css , tutto ha iniziato a funzionare bene. Giocando un po ‘di più ho scoperto che se ci sono sia main.css che main.min.css , l’aggiornamento di main.min.css aggiornerà il bundle … Stranamente, ma almeno prevedibile.

Dopo aver combattuto per capire cosa rende il refresh della cache del bundle, sono giunto ad alcune conclusioni che si spera possano aiutare gli altri:

Se i file .min SONO inclusi come parte del pacchetto:

  • modalità di rilascio + modifica min js code = aggiornamento della cache
  • modalità di rilascio + modifica non min codice js = nessun aggiornamento della cache
  • modalità di debug + modifica min js code = nessun aggiornamento della cache
  • modalità di debug + modifica non min js code = nessun aggiornamento della cache

Se i file .min NON sono inclusi come parte del pacchetto:

  • modalità di debug + modifica codice js = nessun aggiornamento della cache
  • modalità di rilascio + modifica js code = aggiornamento della cache

Gli appunti

  • Per modalità di debug intendo la compilazione di web.config debug = true (e BundleTable.EnableOptimizations = false o viene omessa)
  • Per modalità di rilascio intendo la compilazione di web.config debug = false (e BundleTable.EnableOptimizations = true o è omessa
  • Assicurati di apportare modifiche al codice. Modifiche quali spazi e commenti non influiscono sul j minificato risultante, quindi il server è corretto in quanto non vi sono modifiche (quindi la cache del bundle non viene aggiornata).

Ok, ecco la mia storia. Ho disabilitato la generazione di file min per meno file in Web Essentials. I vecchi file min non sono stati cancellati, e bundle thingy ha visto quelli invece dei CSS aggiornati. In bocca al lupo!

MODIFICARE

Qualche tempo dopo ho passato altre 2 ore buone sullo stesso problema. Questa volta è stata colpa mia, immagino – ho dimenticato la tilde principale, cioè ho scritto

 Scripts.Render("/js/script") 

al posto di

 Scripts.Render("~/js/script") 

Per qualsiasi motivo a volte ha funzionato, ea volte non ha fatto nulla del genere.

In realtà ho deciso di non utilizzare System.Web.Optimization per questa attività, ma ho trovato Microsoft Ajax Minifier, che è anche incluso in WebGrease.dll, che viene fornito con la libreria MVC4 System.Web.Optimization. Ho scritto la seguente funzione, che ho poi chiamato in Application_Start per ogni file minificato:

  public static void MinifyFile(string virtualPath) { string fullPath = HttpContext.Current.Server.MapPath(virtualPath); string extension = Path.GetExtension(fullPath).ToLower(); string targetPath = fullPath.Substring(0, fullPath.Length - extension.Length) + ".min" + extension; if(File.Exists(fullPath) == false) { throw new FileNotFoundException("File not found: " + fullPath); } string input = File.ReadAllText(fullPath); string output; if (extension == ".js") { Microsoft.Ajax.Utilities.Minifier jsmin = new Microsoft.Ajax.Utilities.Minifier(); output = jsmin.MinifyJavaScript(input); } else if (extension == ".css") { Microsoft.Ajax.Utilities.Minifier jsmin = new Microsoft.Ajax.Utilities.Minifier(); output = jsmin.MinifyStyleSheet(input); } else { throw new NotSupportedException(extension + " is not supported for minification."); } File.WriteAllText(targetPath, output); } 

Ora, la mia applicazione sta riducendo tutti i file su Application_Start.

Tieni presente che se utilizzi Google Chrome la memorizzazione nella cache è piuttosto aggressiva. Per garantire che nulla venga memorizzato nella cache, puoi fare Ctrl-Shift-I per visualizzare il riquadro degli sviluppatori. Vai alla Network e fai clic su Disable Cache . Assicurati di tenerlo aperto. Ora aggiorna la pagina. La tua cache dovrebbe essere cancellata e le modifiche al file dovrebbero essere riflesse ora.

Disabilita cache in Google Chrome

L’operazione di raggruppamento è sensibile al maiuscolo / minuscolo. Assicurati che il nome del file abbia il caso corretto.

Ho dovuto modificare una riga nel mio BundleConfig.cs:

 bundles.Add(new StyleBundle("~/Content/css").Include( "~/Content/bootstrap.css", "~/Content/Site.css")); <-- Uppercased. 

Non sono sicuro che la funzione attualmente disponibile supporti davvero il fatto di essere un CDN, poiché si basa implicitamente sull’URL per contenere un hashcode per impedire la memorizzazione nella cache del browser.

Ma posso provare ad aiutarti a cercare di arrivarci, e forse è ansible oggi … Un problema che potrebbe potenzialmente essere un roadblock è che BundleHandler restituirà 304 su qualsiasi richiesta di bundle che contiene l’intestazione IfLastModified, poiché l’ipotesi è che la cache del browser è sempre valida a causa dell’impronta digitale nell’URL.

Puoi aggiungere alcuni dettagli su come stai rendendo i riferimenti ai pacchetti? Stai usando qualcosa come Scripts.Render (“~ / Scripts / plugin / pluginjs”)?

Il tuo tag script del bundle dovrebbe assomigliare a questo:

 Good:  

Se i tag script fanno riferimento al bundle non contenente alcuna stringa di versione, è probabile che ciò spieghi i problemi di memorizzazione nella cache che si verificano:

 Not good: