HTML Minification mit ASP.NET MVC

Hallo Abt,

dazu habe ich gleich mehrere Anmerkungen:

1. Pattern nur bedingt korrekt: Das Regex pattern matched nur aufeinanderfolgende Whitespaces und lässt das erste stehen, d.h. es werden z.b. nicht alle Zeilenumbrüche entfernt wie angegeben, sondern aus \r\n wird \r. Das lässt sich noch optimieren.
   
2. Problem mit <pre> Tags: Dein Regex-Pattern versucht zwar diese Problem zu lösen, allerdings wäre das so nur korrekt, wenn du dein Regex auf den kompletten HTML-String anwendest. Du arbeitest in der Write-Methode aber Block-basiert, d.h. ein </pre>-Tag könnte erst im nächsten Block enden, wodurch du fälschlicherweise die Whitespaces entfernen würdest.
   
3. Performance: Die von dir genutzte Performance-Messung macht keinen Sinn, da die OnActionExecuted-Methode deines Filters (und damit das Ende der Messung) aufgerufen wird, bevor die eigentliche Minification stattfindet. Wenn du misst wie lange das eigentliche Minifizieren dauert, wirst du sehen, dass es einen wahnsinnig hohen Performance Impact hat. Ich habe eine kurze Messung gemacht, mit und ohne Minifikation (jeweils 100 Durchläufe). Das Ergebnis ist als Boxplot unten beigefügt.

Also ich hab mir aus Github den Master runtergeladen und da kommt das Minify definitiv danach. Ich hab zum Spaß einfach mal ein Thread.Sleep(100) (nach dem Minify) eingefügt und die Ausgabe auf der Webseite war weiterhin unter 100 Ticks. Oder verwendest du eine andere Version?

Bzgl. dem Block-basiert: Dein Quellcode zeigt doch, dass du in der Write-Methode mit dem übergebenen Buffer und damit nicht mit dem gesamten HTML auf einmal arbeitest. Du wirst beim Debuggen sicher sehen, dass mehrmals in die Write-Methode gesprungen wird.

Übrigens kann ich mir das mit den 2ms nicht wirklich vorstellen. Mein Rechner benötigt für folgendes schon länger als 3ms:

C#-Code:

private static readonly Regex RegExpressionWhiteSpaces = new Regex(@"(?<=\s)\s+(?![^<>]*</pre>)", RegexOptions.Compiled); private const string Test = "lksdhf sdkhf  shkdfahöksdklf slfhkl ahklfahklfhl ksafdhk fafdhkl fldhk fldhk sdhklfhkl afhkl fdhkl afhkl fhkl ahklf hk sdakfh sdafh lsd aflk sdlfs "; static void Main(string[] args) {     var sw = Stopwatch.StartNew();     RegExpressionWhiteSpaces.Replace(Test, string.Empty);     sw.Stop();     Console.WriteLine(sw.Elapsed.TotalMilliseconds);     Console.Read(); }

Danke für den Einwand mit der Blockverarbeitung ab einer gewissen Seitengröße
Hier das Update:

C#-Code:

namespace HtmlMinifyExample {     /// <summary>     /// Minifies the HTML code. Removes all whitespaces     /// </summary>     public class HtmlMinifyStream : MemoryStream     {         #region Properties and Fields         /// <summary>         /// Regex; Pattern by http://stackoverflow.com/questions/8762993/remove-white-space-from-entire-html-but-inside-pre-with-regular-expressions         /// </summary>         private static readonly Regex RegExpressionWhiteSpaces = new Regex( @"(?<=\s)\s+(?![^<>]*</pre>)", RegexOptions.Compiled );         // Regex instances are read-only => Thread-safe and can be static         /// <summary>         /// Stream to minify.         /// Do not dispose by yourself!         /// </summary>         private readonly Stream _responseStream;         #endregion         #region Constructor         /// <summary>         /// Create new minify stream based on the current response stream. Overwrites contents         /// </summary>         public HtmlMinifyStream( Stream responseStream )         {             this._responseStream = responseStream;         }         #endregion         /// <summary>         /// Override close method and implement minification         /// </summary>         public override void Close()         {             // Minify             var minified = Encoding.UTF8.GetBytes( RegExpressionWhiteSpaces.Replace( Encoding.UTF8.GetString( this.ToArray( ) ), String.Empty ) );             // write data to stream             _responseStream.Write( minified, 0, minified.Length );             // flush all             _responseStream.Flush( );             base.Close( );         }     } }

Es wird nur noch ein einziges Mal minified.

Ich hab mal die aktuelle Seite von heise.de verwendet, das sind 571109 Zeichen laut Deinem Code - also mehr als das 20-Fache Deines Tests:
Resultat siehe Anhang.

Du musst aber eins Bedenken: HtmlMinifcation ist die Optimierung auf der "letzten Meile" und ist Bestandteil des Cachings.
Wenn Du ständig Seiten mit einer halben Million Zeichen komprimierst, dann solltest Du Dir eher Überlegungen über das Gesamtkonzept machen.
"Realistisch" ist dieser Test also gewiss nicht.

In modernen Webseiten wird der Rahmen ohne dynamischen Daten nur noch aus dem Cache geliefert. Hier spielt Minification eine Rolle, weil der komprimierte, statische Inhalt anschließend nur noch gepusht wird - und genau hier ist es interessant.
Die Daten werden dann dynamisch zB wie AngularJS und Co nachgeladen.

Statistik auf Azure - Vorher und Nachher
Lieferung ohne Minify aus dem Cache: 51ms ( Info)
Ohne Minify Filter: 93ms ( Info)
Mit Minify Filter: 104ms ( Info)
Lieferung mit Minify aus dem Cache: 40ms ( Info)

Das Auslieferungsvolumen hat sich um 27% verringert - das Lieferverhalten aus dem Cache um 20% verbessert.
Hast noch weitere Gegenargumente? :)