public void Render(HtmlTextWriter writer, Action <HtmlTextWriter> renderHandler) { if (!DisableMinification) { IMarkupMinificationManager minificationManager = _minificationManager ?? GetDefaultMinificationManager(); HttpContext context = HttpContext.Current; HttpResponse response = context.Response; HttpRequest request = context.Request; using (var htmlwriter = new HtmlTextWriter(new StringWriter())) { renderHandler(htmlwriter); string content = htmlwriter.InnerWriter.ToString(); bool isMinified = false; Encoding encoding = response.ContentEncoding; int responseSize = encoding.GetByteCount(content); string httpMethod = request.HttpMethod; string mediaType = response.ContentType; string currentUrl = request.RawUrl; if (response.StatusCode == 200 && _configuration.IsAllowableResponseSize(responseSize) && minificationManager.IsSupportedHttpMethod(httpMethod) && minificationManager.IsSupportedMediaType(mediaType) && minificationManager.IsProcessablePage(currentUrl)) { IMarkupMinifier minifier = minificationManager.CreateMinifier(); MarkupMinificationResult minificationResult = minifier.Minify(content, currentUrl, encoding, minificationManager.GenerateStatistics); if (minificationResult.Errors.Count == 0) { if (_configuration.IsPoweredByHttpHeadersEnabled()) { minificationManager.AppendPoweredByHttpHeader((key, value) => { response.Headers[key] = value; }); } writer.Write(minificationResult.MinifiedContent); isMinified = true; } } if (!isMinified) { writer.Write(content); } } } else { renderHandler(writer); } }
public override void Close() { bool isEncodedContent = HttpHeadersHelpers.IsEncodedContent(_response.Headers); if (!isEncodedContent) { byte[] cachedBytes = _cachedStream.ToArray(); int cachedByteCount = cachedBytes.Length; bool isMinified = false; if (_configuration.IsAllowableResponseSize(cachedByteCount)) { string content = _encoding.GetString(cachedBytes); IMarkupMinifier minifier = _minificationManager.CreateMinifier(); MarkupMinificationResult minificationResult = minifier.Minify(content, _currentUrl, _encoding, _minificationManager.GenerateStatistics); if (minificationResult.Errors.Count == 0) { if (_configuration.IsPoweredByHttpHeadersEnabled()) { _minificationManager.AppendPoweredByHttpHeader((key, value) => { _response.Headers[key] = value; }); } using (var writer = new StreamWriter(_originalStream, _encoding)) { writer.Write(minificationResult.MinifiedContent); } isMinified = true; } } if (!isMinified) { _cachedStream.Seek(0, SeekOrigin.Begin); _cachedStream.CopyTo(_originalStream); } } _cachedStream.Clear(); _originalStream.Close(); if (isEncodedContent) { throw new InvalidOperationException( string.Format( AspNetCommonStrings.MarkupMinificationIsNotApplicableToEncodedContent, _response.Headers["Content-Encoding"] ) ); } }
public override void Close() { byte[] cacheBytes = _cacheStream.ToArray(); int cacheSize = cacheBytes.Length; bool isMinified = false; if (_configuration.IsAllowableResponseSize(cacheSize)) { string content = _encoding.GetString(cacheBytes); IMarkupMinifier minifier = _minificationManager.CreateMinifier(); MarkupMinificationResult minificationResult = minifier.Minify(content, _currentUrl, _encoding, false); if (minificationResult.Errors.Count == 0) { if (_configuration.IsPoweredByHttpHeadersEnabled()) { _minificationManager.AppendPoweredByHttpHeader((key, value) => { _response.Headers[key] = value; }); } using (var writer = new StreamWriter(_stream, _encoding)) { writer.Write(minificationResult.MinifiedContent); } isMinified = true; } } if (!isMinified) { _cacheStream.Seek(0, SeekOrigin.Begin); _cacheStream.CopyTo(_stream); } _cacheStream.SetLength(0); _stream.Close(); }
public async Task Finish() { if (_minificationEnabled) { byte[] cachedBytes = _cachedStream.ToArray(); int cachedByteCount = cachedBytes.Length; bool isMinified = false; if (cachedByteCount > 0 && _options.IsAllowableResponseSize(cachedByteCount)) { Encoding encoding = _encoding ?? Encoding.GetEncoding(0); string content = encoding.GetString(cachedBytes); IMarkupMinifier minifier = _currentMinificationManager.CreateMinifier(); MarkupMinificationResult minificationResult = minifier.Minify(content, _currentUrl, _encoding, _currentMinificationManager.GenerateStatistics); if (minificationResult.Errors.Count == 0) { IHeaderDictionary responseHeaders = _context.Response.Headers; Action <string, string> appendHttpHeader = (key, value) => { responseHeaders.Append(key, new StringValues(value)); }; if (_options.IsPoweredByHttpHeadersEnabled()) { _currentMinificationManager.AppendPoweredByHttpHeader(appendHttpHeader); } responseHeaders.Remove(HeaderNames.ContentMD5); string processedContent = minificationResult.MinifiedContent; byte[] processedBytes = encoding.GetBytes(processedContent); int processedByteCount = processedBytes.Length; if (_compressionEnabled) { _currentCompressor.AppendHttpHeaders(appendHttpHeader); responseHeaders.Remove(HeaderNames.ContentLength); await _compressionStream.WriteAsync(processedBytes, 0, processedByteCount); } else { responseHeaders[HeaderNames.ContentLength] = processedByteCount.ToString(); await _originalStream.WriteAsync(processedBytes, 0, processedByteCount); } isMinified = true; } if (!isMinified) { Stream outputStream = _compressionEnabled ? _compressionStream : _originalStream; _cachedStream.Seek(0, SeekOrigin.Begin); await _cachedStream.CopyToAsync(outputStream); } } _cachedStream.Clear(); } }
protected async Task InternalFinishAsync() { if (_minificationEnabled) { bool isMinified = false; int cachedByteCount = (int)_cachedStream.Length; IHeaderDictionary responseHeaders = _context.Response.Headers; Action <string, string> appendHttpHeader = (key, value) => { responseHeaders.Append(key, new StringValues(value)); }; if (cachedByteCount > 0 && _options.IsAllowableResponseSize(cachedByteCount)) { Encoding encoding = _encoding ?? _options.DefaultEncoding; #if NETSTANDARD1_3 byte[] cachedBytes = _cachedStream.ToArray(); string content = encoding.GetString(cachedBytes); #else byte[] cachedBytes = _cachedStream.GetBuffer(); string content = encoding.GetString(cachedBytes, 0, cachedByteCount); #endif IMarkupMinifier minifier = _currentMinificationManager.CreateMinifier(); MarkupMinificationResult minificationResult = minifier.Minify(content, _currentUrl, _encoding, _currentMinificationManager.GenerateStatistics); if (minificationResult.Errors.Count == 0) { if (_options.IsPoweredByHttpHeadersEnabled()) { _currentMinificationManager.AppendPoweredByHttpHeader(appendHttpHeader); } responseHeaders.Remove(HeaderNames.ContentMD5); string processedContent = minificationResult.MinifiedContent; var byteArrayPool = ArrayPool <byte> .Shared; int processedByteCount = encoding.GetByteCount(processedContent); byte[] processedBytes = byteArrayPool.Rent(processedByteCount); try { encoding.GetBytes(processedContent, 0, processedContent.Length, processedBytes, 0); if (_compressionEnabled) { _currentCompressor.AppendHttpHeaders(appendHttpHeader); responseHeaders.Remove(HeaderNames.ContentLength); await _compressionStream.WriteAsync(processedBytes, 0, processedByteCount); } else { responseHeaders[HeaderNames.ContentLength] = processedByteCount.ToString(); await _originalStream.WriteAsync(processedBytes, 0, processedByteCount); } } finally { byteArrayPool.Return(processedBytes); } isMinified = true; } } if (!isMinified) { Stream outputStream; if (_compressionEnabled) { outputStream = _compressionStream; _currentCompressor.AppendHttpHeaders(appendHttpHeader); } else { outputStream = _originalStream; } _cachedStream.Seek(0, SeekOrigin.Begin); await _cachedStream.CopyToAsync(outputStream); } _cachedStream.Clear(); } }