Add the injector middleware

Tratcher · Tratcher · commit 569ab62e4c48 · 2017-08-21T21:09:33.000-07:00
diff --git a/MiddlewareInjector/MiddlewareInjectorExtensions.cs b/MiddlewareInjector/MiddlewareInjectorExtensions.cs
@@ -0,0 +1,16 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+
+namespace MiddlewareInjector
+{
+    public static class MiddlewareInjectorExtensions
+    {
+        public static IApplicationBuilder UseMiddlewareInjector(this IApplicationBuilder builder, MiddlewareInjectorOptions options)
+        {
+            return builder.UseMiddleware<MiddlewareInjectorMiddleware>(builder.New(), options);
+        }
+    }
+}
diff --git a/MiddlewareInjector/MiddlewareInjectorMiddleware.cs b/MiddlewareInjector/MiddlewareInjectorMiddleware.cs
@@ -0,0 +1,43 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+
+namespace MiddlewareInjector
+{
+    public class MiddlewareInjectorMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly IApplicationBuilder _builder;
+        private readonly MiddlewareInjectorOptions _options;
+        private RequestDelegate _subPipeline;
+
+        public MiddlewareInjectorMiddleware(RequestDelegate next, IApplicationBuilder builder, MiddlewareInjectorOptions options)
+        {
+            _next = next ?? throw new ArgumentNullException(nameof(next));
+            _builder = builder ?? throw new ArgumentNullException(nameof(builder));
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public Task Invoke(HttpContext httpContext)
+        {
+            var injector = _options.GetInjector();
+            if (injector != null)
+            {
+                var builder = _builder.New();
+                injector(builder);
+                builder.Run(_next);
+                _subPipeline = builder.Build();
+            }
+
+            if (_subPipeline != null)
+            {
+                return _subPipeline(httpContext);
+            }
+
+            return _next(httpContext);
+        }
+    }
+}
diff --git a/MiddlewareInjector/MiddlewareInjectorOptions.cs b/MiddlewareInjector/MiddlewareInjectorOptions.cs
@@ -0,0 +1,24 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+
+namespace MiddlewareInjector
+{
+    public class MiddlewareInjectorOptions
+    {
+        private Action<IApplicationBuilder> _injector;
+
+        public void InjectMiddleware(Action<IApplicationBuilder> builder)
+        {
+            Interlocked.Exchange(ref _injector, builder);
+        }
+
+        internal Action<IApplicationBuilder> GetInjector()
+        {
+            return Interlocked.Exchange(ref _injector, null);
+        }
+    }
+}
diff --git a/MiddlewareInjector/Startup.cs b/MiddlewareInjector/Startup.cs
@@ -25,9 +25,49 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
                 app.UseDeveloperExceptionPage();
             }
 
-            app.Run(async (context) =>
+            var injectorOptions = new MiddlewareInjectorOptions();
+
+            app.UseMiddlewareInjector(injectorOptions);
+
+            app.Run(async context =>
+            {
+                context.Response.ContentType = "text/html";
+                await context.Response.WriteAsync("<html><body>");
+                if (context.Request.Path.Equals("/clear"))
+                {
+                    injectorOptions.InjectMiddleware(_ => { });
+                    await context.Response.WriteAsync("Cleared middleware<br>");
+                }
+                else if (context.Request.Path.Equals("/inject"))
+                {
+                    injectorOptions.InjectMiddleware(InjectContent);
+
+                    await context.Response.WriteAsync("Injected middleware<br>");
+                }
+                else
+                {
+                    await context.Response.WriteAsync("Hello World!<br>");
+                }
+                await context.Response.WriteAsync("<a href=\"/inject\">Inject</a><br>");
+                await context.Response.WriteAsync("<a href=\"/testpath\">Test Path</a><br>");
+                await context.Response.WriteAsync("<a href=\"/clear\">Clear</a><br>");
+                await context.Response.WriteAsync("<a href=\"/\">Home</a><br>");
+                await context.Response.WriteAsync("</body></html>");
+            });
+        }
+
+        public void InjectContent(IApplicationBuilder builder)
+        {
+            builder.Map("/testpath", subBuilder =>
             {
-                await context.Response.WriteAsync("Hello World!");
+                subBuilder.Run(async context =>
+                {
+                    context.Response.ContentType = "text/html";
+                    await context.Response.WriteAsync("<html><body>");
+                    await context.Response.WriteAsync("Injected content<br>");
+                    await context.Response.WriteAsync("<a href=\"/\">Home</a><br>");
+                    await context.Response.WriteAsync("</body></html>");
+                });
             });
         }
     }
