/// <summary> /// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="configureRoutes">A callback to configure MVC routes.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseMvc( this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (configureRoutes == null) { throw new ArgumentNullException(nameof(configureRoutes)); } VerifyMvcIsRegistered(app); var middlewarePipelineBuilder = app.ApplicationServices.GetRequiredService <MiddlewareFilterBuilder>(); middlewarePipelineBuilder.ApplicationBuilder = app.New(); var routes = new RouteBuilder(app) { DefaultHandler = app.ApplicationServices.GetRequiredService <MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); return(app.UseRouter(routes.Build())); }
/// <summary> /// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="configureRoutes">A callback to configure MVC routes.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseMvcXT(this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } // ... verify if AddMvcXT was done before calling UseMvcXT; // MvcXTMarkerService is here to make sure if all the services were added ... if (app.ApplicationServices.GetService(typeof(MvcXTMarkerService)) == null) { throw new InvalidOperationException(string.Format("You must call {{{0}}}.{{{1}}} in your '{2}' start up class method first for adding the CoreXT MVC pipeline.", nameof(IServiceCollection), "AddMvcXT", "ConfigureServices(...)")); } var middlewarePipelineBuilder = app.ApplicationServices.GetRequiredService <MiddlewareFilterBuilder>(); //? middlewarePipelineBuilder.ApplicationBuilder = app.New(); //? var routes = new RouteBuilder(app, app.ApplicationServices.GetRequiredService <MvcRouteHandler>()); // ('MvcRouteHandler' is the default handler for mapping routes [i.e. routes.MapRoute()]) configureRoutes?.Invoke(routes); // (note: if users call 'MapRoute()', it requires 'routes.DefaultHandler' to be set on the route builder) routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); //routes.UseAttributeRouting(); return(app.UseRouterXT(routes.Build())); }
public static IApplicationBuilder UsePageContext(this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (configureRoutes == null) { throw new ArgumentNullException(nameof(configureRoutes)); } // Verify if AddMvc was done before calling UseMvc // We use the MvcMarkerService to make sure if all the services were added. if (app.ApplicationServices.GetService(typeof(MvcMarkerService)) == null) { throw new InvalidOperationException("FormatUnableToFindServices" + "AddMvc" + "ConfigureServices(...)"); } var routes = new RouteBuilder(app) { DefaultHandler = app.ApplicationServices.GetRequiredService <DeviserRouteHandler>(), //DefaultHandler = app.ApplicationServices.GetRequiredService<MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); return(app.UseMiddleware <PageContextMiddleware>(routes.Build())); }
/// <summary> /// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="configureRoutes">A callback to configure MVC routes.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseMvc( this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (configureRoutes == null) { throw new ArgumentNullException(nameof(configureRoutes)); } // Verify if AddMvc was done before calling UseMvc // We use the MvcMarkerService to make sure if all the services were added. MvcServicesHelper.ThrowIfMvcNotRegistered(app.ApplicationServices); var routes = new RouteBuilder(app) { DefaultHandler = new MvcRouteHandler(), }; configureRoutes(routes); // Adding the attribute route comes after running the user-code because // we want to respect any changes to the DefaultHandler. routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute( routes.DefaultHandler, app.ApplicationServices)); return(app.UseRouter(routes.Build())); }
private static void PrepareApplicationAndRoutes(StartupMethods startupMethods) { var applicationBuilder = new MockedApplicationBuilder(serviceProvider); startupMethods?.ConfigureDelegate?.Invoke(applicationBuilder); AdditionalApplicationConfiguration?.Invoke(applicationBuilder); var routeBuilder = new RouteBuilder(applicationBuilder) { DefaultHandler = new RouteHandler(NullHandler) }; for (int i = 0; i < applicationBuilder.Routes.Count; i++) { var route = applicationBuilder.Routes[i]; routeBuilder.Routes.Add(route); } AdditionalRoutes?.Invoke(routeBuilder); if (StartupType == null || routeBuilder.Routes.Count == 0) { routeBuilder.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); routeBuilder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute( routeBuilder.DefaultHandler, serviceProvider)); } router = routeBuilder.Build(); }
public async Task <string> GetIdentifierAsync(object context) { if (!(context is HttpContext)) { throw new MultiTenantException(null, new ArgumentException($"\"{nameof(context)}\" type must be of type HttpContext", nameof(context))); } var httpContext = context as HttpContext; // Create the IRouter if not yet created. // Done here rather than at startup so that order doesn't matter in ConfigureServices. if (router == null) { var rb = new MultiTenantRouteBuilder(MultiTenantMiddleware.ApplicationServices); // Apply explicit routes. configRoutes(rb); // Insert attribute based routes. rb.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(MultiTenantMiddleware.ApplicationServices)); router = rb.Build(); } // Check the route. var routeContext = new RouteContext(httpContext); await router.RouteAsync(routeContext); object identifier = null; routeContext.RouteData?.Values.TryGetValue(tenantParam, out identifier); return(identifier as string); }
public async Task AttributeRouting_MultipleErrors() { // Arrange var action1 = CreateAction("DisallowedParameter1", "{foo}/{action}"); action1.RouteValues.Add("foo", "bleh"); var action2 = CreateAction("DisallowedParameter2", "cool/{action}"); action2.RouteValues.Add("action", "hey"); var expectedMessage = "The following errors occurred with attribute routing information:" + Environment.NewLine + Environment.NewLine + "For action: 'DisallowedParameter1'" + Environment.NewLine + "Error: The attribute route '{foo}/{action}' cannot contain a parameter named '{foo}'. " + "Use '[foo]' in the route template to insert the value 'bleh'." + Environment.NewLine + Environment.NewLine + "For action: 'DisallowedParameter2'" + Environment.NewLine + "Error: The attribute route 'cool/{action}' cannot contain a parameter named '{action}'. " + "Use '[action]' in the route template to insert the value 'hey'."; var services = CreateServices(action1, action2); var route = AttributeRouting.CreateAttributeMegaRoute(services); // Act & Assert var ex = await Assert.ThrowsAsync <RouteCreationException>(async() => { await route.RouteAsync(new RouteContext(new DefaultHttpContext())); }); Assert.Equal(expectedMessage, ex.Message); }
public async Task AttributeRouting_SyntaxErrorInTemplate() { // Arrange var value = "a/dkfk"; var action = CreateAction("InvalidTemplate", "{" + value + "}"); var expectedMessage = "The following errors occurred with attribute routing information:" + Environment.NewLine + Environment.NewLine + "For action: 'InvalidTemplate'" + Environment.NewLine + "Error: The route parameter name 'a/dkfk' is invalid. Route parameter names must be non-empty and " + "cannot contain these characters: '{', '}', '/'. The '?' character marks a parameter as optional, " + "and can occur only at the end of the parameter. The '*' character marks a parameter as catch-all, " + "and can occur only at the start of the parameter. (Parameter 'routeTemplate')"; var services = CreateServices(action); var route = AttributeRouting.CreateAttributeMegaRoute(services); var routeContext = new RouteContext(new DefaultHttpContext()); // Act & Assert var ex = await Assert.ThrowsAsync <RouteCreationException>(() => route.RouteAsync(routeContext)); Assert.Equal(expectedMessage, ex.Message); }
private static IRouter GenerateRouter(IApplicationBuilder applicationBuilder) { var routes = new RouteBuilder(applicationBuilder) { DefaultHandler = applicationBuilder.ApplicationServices.GetRequiredService <MvcRouteHandler>() }; routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(applicationBuilder.ApplicationServices)); return(routes.Build()); }
/// <summary> /// Use Finbuckle.MultiTenant middleware with routing support in processing the request. /// </summary> /// <param name="builder">The <c>IApplicationBuilder<c/> instance the extension method applies to.</param> /// <returns>The same <c>IApplicationBuilder</c> passed into the method.</returns> public static IApplicationBuilder UseMultiTenant(this IApplicationBuilder builder, Action <IRouteBuilder> configRoute) { var rb = new RouteBuilder(builder, new MultiTenantRouteHandler()); configRoute(rb); // insert attribute based routes rb.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(builder.ApplicationServices)); var routes = rb.Build(); return(builder.UseMiddleware <MultiTenantMiddleware>(routes)); }
public void Configure(IRouteBuilder builder) { builder.Routes.Add(new Route( builder.DefaultHandler, "Default", "{area:exists}/{controller}/{action}/{id?}", null, null, null, builder.ServiceProvider.GetService <IInlineConstraintResolver>()) ); builder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(builder.ServiceProvider)); }
public static IBuilder UseMvc([NotNull] this IBuilder app, [NotNull] Action <IRouteBuilder> configureRoutes) { var routes = new RouteBuilder { DefaultHandler = new MvcRouteHandler(), ServiceProvider = app.ApplicationServices }; routes.Routes.Add(AttributeRouting.CreateAttributeMegaRoute( routes.DefaultHandler, app.ApplicationServices)); configureRoutes(routes); return(app.UseRouter(routes.Build())); }
public static IApplicationBuilder UseApiAuthorized(this IApplicationBuilder builder, Action <IRouteBuilder> configureRoutes) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } var routes = new RouteBuilder(builder) { DefaultHandler = builder.ApplicationServices.GetRequiredService <MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(builder.ApplicationServices)); var router = routes.Build(); return(builder.UseMiddleware <ApiAuthorizedMiddleware>(router)); }
public void Configure(IRouteBuilder builder) { var inlineConstraintResolver = _serviceProvider.GetService <IInlineConstraintResolver>(); // The default route is added to each tenant as a template route, with a prefix builder.Routes.Add(new Route( builder.DefaultHandler, "Default", "{area:exists}/{controller}/{action}/{id?}", null, null, null, inlineConstraintResolver) ); builder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(_serviceProvider)); }
public static IApplicationBuilder UseGetRoutesMiddleware(this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } var routes = new RouteBuilder(app) { DefaultHandler = app.ApplicationServices.GetRequiredService <MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); var router = routes.Build(); return(app.UseMiddleware <GetRoutesMiddleware>(router)); }
public static IApplicationBuilder UseDebby( this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { MvcServicesHelper.ThrowIfMvcNotRegistered(app.ApplicationServices); var routes = new RouteBuilder { DefaultHandler = new MvcRouteHandler(), ServiceProvider = app.ApplicationServices }; routes.Routes.Add(AttributeRouting.CreateAttributeMegaRoute( routes.DefaultHandler, app.ApplicationServices)); configureRoutes(routes); return(app.UseRouter(routes.Build())); }
public async Task <string> GetIdentifierAsync(object context) { if (!(context is HttpContext)) { throw new MultiTenantException(null, new ArgumentException($"\"{nameof(context)}\" type must be of type HttpContext", nameof(context))); } var httpContext = context as HttpContext; // Detect if app model changed (eg Razor Pages file update) if (actionDescriptorsVersion != actionDescriptorCollectionProvider.ActionDescriptors.Version) { actionDescriptorsVersion = actionDescriptorCollectionProvider.ActionDescriptors.Version; router = null; } // Create the IRouter if not yet created. if (router == null) { var rb = new MultiTenantRouteBuilder(httpContext.RequestServices); // Apply explicit routes. configRoutes(rb); // Insert attribute based routes. rb.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(httpContext.RequestServices)); router = rb.Build(); } // Check the route. var routeContext = new RouteContext(httpContext); await router.RouteAsync(routeContext) .ConfigureAwait(false); object identifier = null; routeContext.RouteData?.Values.TryGetValue(tenantParam, out identifier); return(identifier as string); }
public static IApplicationBuilder UseMvc( [NotNull] this IApplicationBuilder app, [NotNull] Action <IRouteBuilder> configureRoutes) { // Verify if AddMvc was done before calling UseMvc // We use the MvcMarkerService to make sure if all the services were added. MvcServicesHelper.ThrowIfMvcNotRegistered(app.ApplicationServices); var routes = new RouteBuilder { DefaultHandler = new MvcRouteHandler(), ServiceProvider = app.ApplicationServices }; routes.Routes.Add(AttributeRouting.CreateAttributeMegaRoute( routes.DefaultHandler, app.ApplicationServices)); configureRoutes(routes); return(app.UseRouter(routes.Build())); }
/// <summary> /// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="configureRoutes">A callback to configure MVC routes.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseMvc( this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (configureRoutes == null) { throw new ArgumentNullException(nameof(configureRoutes)); } // Verify if AddMvc was done before calling UseMvc // We use the MvcMarkerService to make sure if all the services were added. if (app.ApplicationServices.GetService(typeof(MvcMarkerService)) == null) { throw new InvalidOperationException(Resources.FormatUnableToFindServices( nameof(IServiceCollection), "AddMvc", "ConfigureServices(...)")); } var routes = new RouteBuilder(app) { DefaultHandler = new MvcRouteHandler(), }; configureRoutes(routes); // Adding the attribute route comes after running the user-code because // we want to respect any changes to the DefaultHandler. routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute( routes.DefaultHandler, app.ApplicationServices)); return(app.UseRouter(routes.Build())); }
/// <summary> /// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="configureRoutes">A callback to configure MVC routes.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseMvc( this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (configureRoutes == null) { throw new ArgumentNullException(nameof(configureRoutes)); } // Verify if AddMvc was done before calling UseMvc // We use the MvcMarkerService to make sure if all the services were added. if (app.ApplicationServices.GetService(typeof(MvcMarkerService)) == null) { throw new InvalidOperationException(Resources.FormatUnableToFindServices( nameof(IServiceCollection), "AddMvc", "ConfigureServices(...)")); } var middlewarePipelineBuilder = app.ApplicationServices.GetRequiredService <MiddlewareFilterBuilder>(); middlewarePipelineBuilder.ApplicationBuilder = app.New(); var routes = new RouteBuilder(app) { DefaultHandler = app.ApplicationServices.GetRequiredService <MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); return(app.UseRouter(routes.Build())); }
/// <summary> /// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="configureRoutes">A callback to configure MVC routes.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseMvc( this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (configureRoutes == null) { throw new ArgumentNullException(nameof(configureRoutes)); } VerifyMvcIsRegistered(app); var options = app.ApplicationServices.GetRequiredService <IOptions <MvcOptions> >(); if (options.Value.EnableEndpointRouting) { var message = "Endpoint Routing does not support 'IApplicationBuilder.UseMvc(...)'. To use " + "'IApplicationBuilder.UseMvc' set 'MvcOptions.EnableEndpointRouting = false' inside " + "'ConfigureServices(...)."; throw new InvalidOperationException(message); } var routes = new RouteBuilder(app) { DefaultHandler = app.ApplicationServices.GetRequiredService <MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); return(app.UseRouter(routes.Build())); }
public async Task AttributeRouting_WithControllerActionDescriptor() { // Arrange var controllerType = typeof(HomeController); var actionMethod = controllerType.GetMethod("Index"); var action = new ControllerActionDescriptor(); action.DisplayName = "Microsoft.AspNetCore.Mvc.Routing.AttributeRoutingTest+HomeController.Index"; action.MethodInfo = actionMethod; action.RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) { { "controller", "Home" }, { "action", "Index" }, }; action.AttributeRouteInfo = new AttributeRouteInfo(); action.AttributeRouteInfo.Template = "{controller}/{action}"; var expectedMessage = "The following errors occurred with attribute routing information:" + Environment.NewLine + Environment.NewLine + "For action: 'Microsoft.AspNetCore.Mvc.Routing.AttributeRoutingTest+HomeController.Index'" + Environment.NewLine + "Error: The attribute route '{controller}/{action}' cannot contain a parameter named '{controller}'. " + "Use '[controller]' in the route template to insert the value 'Home'."; var services = CreateServices(action); var route = AttributeRouting.CreateAttributeMegaRoute(services); // Act & Assert var ex = await Assert.ThrowsAsync <RouteCreationException>(async() => { await route.RouteAsync(new RouteContext(new DefaultHttpContext())); }); Assert.Equal(expectedMessage, ex.Message); }
// Build the middleware pipeline for the current tenant public RequestDelegate BuildTenantPipeline( ShellSettings shellSettings, HttpContext httpContext) { var serviceProvider = httpContext.RequestServices; var startUps = serviceProvider.GetServices <IStartup>(); var inlineConstraintResolver = serviceProvider.GetService <IInlineConstraintResolver>(); var appBuilder = new ApplicationBuilder(serviceProvider); var routePrefix = ""; if (!string.IsNullOrWhiteSpace(shellSettings.RequestedUrlPrefix)) { routePrefix = shellSettings.RequestedUrlPrefix + "/"; } var routeBuilder = new RouteBuilder(appBuilder) { DefaultHandler = serviceProvider.GetRequiredService <MvcRouteHandler>() }; // Build prefixed route builder var prefixedRouteBuilder = new PrefixedRouteBuilder( routePrefix, routeBuilder, inlineConstraintResolver); // Configure modules foreach (var startup in startUps) { startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider); } // Add the default template route to each shell prefixedRouteBuilder.Routes.Add(new Route( prefixedRouteBuilder.DefaultHandler, "PlatoDefault", "{area:exists}/{controller}/{action}/{id?}", null, null, null, inlineConstraintResolver) ); // Add attribute routing routeBuilder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(serviceProvider)); // Build router var router = prefixedRouteBuilder.Build(); // Use router appBuilder.UseRouter(router); // Create a captured HttpContext for use outside of application context var capturedHttpContext = serviceProvider.GetService <ICapturedHttpContext>(); capturedHttpContext.Configure(state => state.Contextualize(httpContext)); // Create a captured router for use outside of application context var capturedRouter = serviceProvider.GetService <ICapturedRouter>(); capturedRouter.Configure(options => { options.Router = router; options.BaseUrl = $"{httpContext.Request.Scheme}://{httpContext.Request.Host}{httpContext.Request.PathBase}"; }); // Build & return new pipeline var pipeline = appBuilder.Build(); return(pipeline); }
// Build the middleware pipeline for the current tenant public RequestDelegate BuildTenantPipeline( ShellSettings shellSettings, HttpContext httpContext) { var serviceProvider = httpContext.RequestServices; var startUps = serviceProvider.GetServices <IStartup>(); var inlineConstraintResolver = serviceProvider.GetService <IInlineConstraintResolver>(); var appBuilder = new ApplicationBuilder(serviceProvider); var routePrefix = ""; if (!string.IsNullOrWhiteSpace(shellSettings.RequestedUrlPrefix)) { routePrefix = shellSettings.RequestedUrlPrefix + "/"; } var routeBuilder = new RouteBuilder(appBuilder) { DefaultHandler = serviceProvider.GetRequiredService <MvcRouteHandler>() }; // Build prefixed route builder var prefixedRouteBuilder = new PrefixedRouteBuilder( routePrefix, routeBuilder, inlineConstraintResolver); // Configure modules foreach (var startup in startUps) { startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider); } //// Add the default template route to each shell prefixedRouteBuilder.Routes.Add(new Route( prefixedRouteBuilder.DefaultHandler, "PlatoDefault", "{area:exists}/{controller}/{action}/{id?}", null, null, null, inlineConstraintResolver) ); // Add attribute routing routeBuilder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(serviceProvider)); // TODO: The homepage route is not set via the Plato.Core module // Attempt to get homepage route for tenant from site settings store // If the tenant has not been created yet siteService will return null // if siteService returns null users will be presented with the SetUp module ////var siteService = routeBuilder.ServiceProvider.GetService<ISiteSettingsStore>(); ////if (siteService != null) ////{ //// //// Add the default template route to each shell //// prefixedRouteBuilder.Routes.Add(new Route( //// prefixedRouteBuilder.DefaultHandler, //// "PlatoHome", //// "", //// new HomeRoute(), //// null, //// null, //// inlineConstraintResolver) //// ); //// // Add home page route matching //// var homeRoute = new HomePageRoute( //// shellSettings.RequestedUrlPrefix, //// siteService, //// routeBuilder, //// inlineConstraintResolver); //// routeBuilder.Routes.Add(homeRoute); ////} // ------------------ // Build router var router = prefixedRouteBuilder.Build(); // Use router appBuilder.UseRouter(router); // Create a captured HttpContext for use outside of application context var capturedHttpContext = serviceProvider.GetService <ICapturedHttpContext>(); capturedHttpContext.Configure(state => state.Contextualize(httpContext)); // Create a captured router for use outside of application context var capturedRouter = serviceProvider.GetService <ICapturedRouter>(); capturedRouter.Configure(options => { options.Router = router; options.BaseUrl = $"{httpContext.Request.Scheme}://{httpContext.Request.Host}{httpContext.Request.PathBase}"; }); // Build & return new pipeline var pipeline = appBuilder.Build(); return(pipeline); }