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