public class MinifyHtmlFilterAttribute : ActionFilterAttribute
{
    public override void OnResultExecuted(ResultExecutedContext filterContext)
    {
        HttpContextBase context = filterContext.HttpContext;
        HttpRequestBase request = context.Request;
        HttpResponseBase response = context.Response;
        Encoding encoding = response.ContentEncoding;
        string mediaType = response.ContentType;
        string currentUrl = request.RawUrl;
        var minificationManager = HtmlMinificationManager.Current;

        if (response.Filter != null
            && response.StatusCode == 200
            && minificationManager.IsSupportedMediaType(mediaType) //text/html
            && minificationManager.IsProcessablePage(currentUrl))
        {
            response.Filter = new HtmlMinificationFilterStream(response, minificationManager, currentUrl, encoding, mediaType);
        }
    }
}

public class HtmlMinificationFilterStream : Stream
{
    private readonly HttpResponseBase _response;
    private readonly Stream _stream;
    private readonly MemoryStream _cacheStream = new MemoryStream();

    private readonly IMarkupMinificationManager _minificationManager;

    private readonly string _currentUrl;
    private readonly Encoding _encoding;
    private readonly string _mediaType;
    private int _chunkCount = 0;

    public override bool CanRead
    {
        get { return true; }
    }

    public override bool CanSeek
    {
        get { return true; }
    }

    public override bool CanWrite
    {
        get { return true; }
    }

    public override long Length
    {
        get { return 0; }
    }

    public override long Position
    {
        get;
        set;
    }

    public HtmlMinificationFilterStream(HttpResponseBase response,
        IMarkupMinificationManager minificationManager,
        string currentUrl,
        Encoding encoding,
        string mediaType)
    {
        _response = response;
        _stream = response.Filter;
        _minificationManager = minificationManager;
        _currentUrl = currentUrl;
        _encoding = encoding;
        _mediaType = mediaType;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        return _stream.Read(buffer, offset, count);
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        return _stream.Seek(offset, origin);
    }

    public override void SetLength(long value)
    {
        _stream.SetLength(value);
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        _cacheStream.Write(buffer, 0, count);
        _chunkCount++;
    }

    public override void Flush()
    {
        _stream.Flush();
    }

    public override void Close()
    {
        byte[] cacheBytes = _cacheStream.ToArray();
        int cacheSize = cacheBytes.Length;
        string content = _encoding.GetString(cacheBytes);
        var log = $" | Chunks: {_chunkCount} | Url: {_currentUrl} | Encoding: {_encoding} | MediaType: {_mediaType} | Content: {content}";

        IMarkupMinifier minifier = _minificationManager.CreateMinifier();
        MarkupMinificationResult minificationResult = minifier.Minify(content, _currentUrl, _encoding, false);
        bool isMinified = false;
        if (minificationResult.Errors.Count == 0)
        {
            ExceptionHandler.LogException("MINIFICATION SUCCESS" + log, System.Diagnostics.EventLogEntryType.Warning);
            using (var writer = new StreamWriter(_stream, _encoding))
            {
                writer.Write(minificationResult.MinifiedContent);
            }

            isMinified = true;
        }
        else
        {
            foreach (var error in minificationResult.Errors)
            {
                ExceptionHandler.LogException("Minification Error" + log + " | " + error.SourceFragment, System.Diagnostics.EventLogEntryType.Warning);
            }
        }

        if (!isMinified)
        {
            _cacheStream.Seek(0, SeekOrigin.Begin);
            _cacheStream.CopyTo(_stream);
        }

        _cacheStream.SetLength(0);
        _stream.Close();
    }
}