In WebMarkupMin.AspNetCore3 added support of ASP.NET Core 3.0 Preview 8

Author: Taritsyn

samples/WebMarkupMin.Sample.AspNetCore3.Mvc3/Startup.cs

@@ -78,7 +78,6 @@ public void ConfigureServices(IServiceCollection services)
 			services.AddSingleton<IWmmLogger, WmmThrowExceptionLogger>();
 
 			services.AddControllersWithViews();
-			services.AddRazorPages();
 		}
 
 		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
@@ -111,7 +110,6 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
 				endpoints.MapControllerRoute(
 					name: "default",
 					pattern: "{controller=Home}/{action=Index}/{id?}");
-				endpoints.MapRazorPages();
 			});
 		}
 	}

src/WebMarkupMin.AspNetCore1/BodyWrapperStream.cs renamed to src/WebMarkupMin.AspNetCore1/BodyWrapperStreamBase.cs

@@ -7,7 +7,6 @@
 using System.Threading.Tasks;
 
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.Features;
 using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 
@@ -28,14 +27,14 @@ namespace WebMarkupMin.AspNetCore3
 #endif
 {
 	/// <summary>
-	/// Stream wrapper that apply a markup minification and compression only if necessary
+	/// Base class of stream wrapper that apply a markup minification and compression only if necessary
 	/// </summary>
-	internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
+	internal abstract class BodyWrapperStreamBase : Stream
 	{
 		/// <summary>
 		/// HTTP context
 		/// </summary>
-		private readonly HttpContext _context;
+		protected readonly HttpContext _context;
 
 		/// <summary>
 		/// Original stream
@@ -55,7 +54,7 @@ internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
 		/// <summary>
 		/// Flag for whether to do automatically flush the compression stream
 		/// </summary>
-		private bool _autoFlushCompressionStream = false;
+		protected bool _autoFlushCompressionStream = false;
 
 		/// <summary>
 		/// WebMarkupMin configuration
@@ -72,11 +71,6 @@ internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
 		/// </summary>
 		private readonly IHttpCompressionManager _compressionManager;
 
-		/// <summary>
-		/// HTTP buffering feature
-		/// </summary>
-		private readonly IHttpBufferingFeature _bufferingFeature;
-
 		/// <summary>
 		/// Flag indicating whether the stream wrapper is initialized
 		/// </summary>
@@ -85,12 +79,12 @@ internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
 		/// <summary>
 		/// Flag indicating whether a markup minification is enabled
 		/// </summary>
-		private bool _minificationEnabled = false;
+		protected bool _minificationEnabled = false;
 
 		/// <summary>
 		/// Flag indicating whether a HTTP compression is enabled
 		/// </summary>
-		private bool _compressionEnabled = false;
+		protected bool _compressionEnabled = false;
 
 		/// <summary>
 		/// Current URL
@@ -110,7 +104,7 @@ internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
 		/// <summary>
 		/// Current HTTP compressor
 		/// </summary>
-		private ICompressor _currentCompressor;
+		protected ICompressor _currentCompressor;
 
 		/// <summary>
 		/// Flag indicating whether the current HTTP compressor is initialized
@@ -122,6 +116,11 @@ internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
 		/// </summary>
 		private InterlockedStatedFlag _httpHeadersModifiedForCompressionFlag = new InterlockedStatedFlag();
 
+		/// <summary>
+		/// Flag that the stream wrapper is destroyed
+		/// </summary>
+		private InterlockedStatedFlag _disposedFlag = new InterlockedStatedFlag();
+
 
 		/// <summary>
 		/// Constructs an instance of the stream wrapper
@@ -131,21 +130,19 @@ internal sealed class BodyWrapperStream : Stream, IHttpBufferingFeature
 		/// <param name="options">WebMarkupMin configuration</param>
 		/// <param name="minificationManagers">List of markup minification managers</param>
 		/// <param name="compressionManager">HTTP compression manager</param>
-		/// <param name="bufferingFeature">HTTP buffering feature</param>
-		internal BodyWrapperStream(HttpContext context, Stream originalStream,
+		protected BodyWrapperStreamBase(HttpContext context, Stream originalStream,
 			WebMarkupMinOptions options, IList<IMarkupMinificationManager> minificationManagers,
-			IHttpCompressionManager compressionManager, IHttpBufferingFeature bufferingFeature)
+			IHttpCompressionManager compressionManager)
 		{
 			_context = context;
 			_originalStream = originalStream;
 			_options = options;
 			_minificationManagers = minificationManagers;
 			_compressionManager = compressionManager;
-			_bufferingFeature = bufferingFeature;
 		}
 
 
-		private void Initialize()
+		protected void Initialize()
 		{
 			if (_wrapperInitializedFlag.Set())
 			{
@@ -235,7 +232,7 @@ private void Initialize()
 			}
 		}
 
-		private ICompressor InitializeCurrentCompressor(string acceptEncoding)
+		protected ICompressor InitializeCurrentCompressor(string acceptEncoding)
 		{
 			if (_currentCompressorInitializedFlag.Set())
 			{
@@ -258,8 +255,40 @@ private void ModifyHttpHeadersForCompressionOnce()
 				responseHeaders.Remove(HeaderNames.ContentLength);
 			}
 		}
+#if NET451 || NETSTANDARD2_0 || NETCOREAPP3_0
+
+		private async void InternalWriteAsync(byte[] buffer, int offset, int count, AsyncCallback callback,
+			TaskCompletionSource<object> tcs)
+		{
+			try
+			{
+				await WriteAsync(buffer, offset, count);
+				tcs.TrySetResult(null);
+			}
+			catch (Exception ex)
+			{
+				tcs.TrySetException(ex);
+			}
+
+			if (callback != null)
+			{
+				// Offload callbacks to avoid stack dives on sync completions
+				var ignored = Task.Run(() =>
+				{
+					try
+					{
+						callback(tcs.Task);
+					}
+					catch (Exception)
+					{
+						// Suppress exceptions on background threads
+					}
+				});
+			}
+		}
+#endif
 
-		public async Task Finish()
+		protected async Task InternalFinishAsync()
 		{
 			if (_minificationEnabled)
 			{
@@ -345,38 +374,11 @@ public async Task Finish()
 				_cachedStream.Clear();
 			}
 		}
-#if NET451 || NETSTANDARD2_0 || NETCOREAPP3_0
 
-		private async void InternalWriteAsync(byte[] buffer, int offset, int count, AsyncCallback callback,
-			TaskCompletionSource<object> tcs)
+		public virtual async Task FinishAsync()
 		{
-			try
-			{
-				await WriteAsync(buffer, offset, count);
-				tcs.TrySetResult(null);
-			}
-			catch (Exception ex)
-			{
-				tcs.TrySetException(ex);
-			}
-
-			if (callback != null)
-			{
-				// Offload callbacks to avoid stack dives on sync completions
-				var ignored = Task.Run(() =>
-				{
-					try
-					{
-						callback(tcs.Task);
-					}
-					catch (Exception)
-					{
-						// Suppress exceptions on background threads
-					}
-				});
-			}
+			await Task.Run(() => throw new NotImplementedException());
 		}
-#endif
 
 		#region Stream overrides
 
@@ -527,79 +529,56 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count,
 
 		protected override void Dispose(bool disposing)
 		{
-			if (disposing)
+			if (_disposedFlag.Set())
 			{
-				if (_compressionStream != null)
+				if (disposing)
 				{
-					_compressionStream.Dispose();
-					_compressionStream = null;
-				}
+					if (_compressionStream != null)
+					{
+						_compressionStream.Dispose();
+						_compressionStream = null;
+					}
 
-				_currentCompressor = null;
+					_currentCompressor = null;
 
-				if (_cachedStream != null)
-				{
-					_cachedStream.Dispose();
-					_cachedStream = null;
+					if (_cachedStream != null)
+					{
+						_cachedStream.Dispose();
+						_cachedStream = null;
+					}
+
+					_currentMinificationManager = null;
 				}
 
-				_currentMinificationManager = null;
+				base.Dispose(disposing);
 			}
-
-			base.Dispose(disposing);
 		}
 #if NETCOREAPP3_0
 
 		public override async ValueTask DisposeAsync()
 		{
-			if (_compressionStream != null)
-			{
-				await _compressionStream.DisposeAsync();
-				_compressionStream = null;
-			}
-
-			_currentCompressor = null;
-
-			if (_cachedStream != null)
+			if (_disposedFlag.Set())
 			{
-				await _cachedStream.DisposeAsync();
-				_cachedStream = null;
-			}
-
-			_currentMinificationManager = null;
-
-			await base.DisposeAsync();
-		}
-#endif
-
-		#endregion
+				if (_compressionStream != null)
+				{
+					await _compressionStream.DisposeAsync();
+					_compressionStream = null;
+				}
 
-		#region IHttpBufferingFeature implementation
+				_currentCompressor = null;
 
-		public void DisableRequestBuffering()
-		{
-			_bufferingFeature?.DisableRequestBuffering();
-		}
+				if (_cachedStream != null)
+				{
+					await _cachedStream.DisposeAsync();
+					_cachedStream = null;
+				}
 
-		public void DisableResponseBuffering()
-		{
-			string acceptEncoding = _context.Request.Headers[HeaderNames.AcceptEncoding];
-			ICompressor compressor = InitializeCurrentCompressor(acceptEncoding);
+				_currentMinificationManager = null;
 
-			if (compressor?.SupportsFlush == false)
-			{
-				// Some of the compressors don't support flushing which would block real-time
-				// responses like SignalR.
-				_compressionEnabled = false;
-				_currentCompressor = null;
+				await base.DisposeAsync();
 			}
-			else
-			{
-				_autoFlushCompressionStream = true;
-			}
-
-			_bufferingFeature?.DisableResponseBuffering();
 		}
+#endif
 
 		#endregion
 	}