//<inheritdoc /> public RequestDelegate CreatePipeline() { _logger.LogTrace("Creating new ApplicationBuilder."); IApplicationBuilder app = new ApplicationBuilder(_serviceProvider); app.Properties["host.AppName"] = _tenant.TenantId; _logger.LogTrace("Registering middlewares."); foreach (var middlewareProvider in _middlewareProviders) { middlewareProvider.Configure(app); } var routeBuilder = new RouteBuilder(app) { DefaultHandler = new MvcRouteHandler() }; _logger.LogDebug("Registering route providers."); foreach (var routeProvider in _routeProviders.OrderBy(t => t.RouterPriority)) { routeProvider.ConfigureRoutes(routeBuilder); } _logger.LogTrace("Building tenant router."); app.UseRouter(routeBuilder.Build()); app.Run(async context => { await context.Response.WriteAsync("You in tenant pipeline! " + _tenant.TenantId); }); _logger.LogTrace("Building pipeline"); var pipeline = app.Build(); return pipeline; }
internal async Task EnsureStartedAsync(CancellationToken cancellationToken) { if (Interlocked.CompareExchange(ref this.serverStarted, 1, 0) == 0) { this.host = new WebHostBuilder() .UseKestrel() .ConfigureServices(s => s.AddRouting()) .UseUrls(this.appAddress) .Configure(app => { var routes = new RouteBuilder(app); foreach (DaprListenerBase listener in this.listeners) { // CONSIDER: Each listener should return a route object (or a collection) // instead of having direct access to the builder. This will // improve encapsulation and enable better logging. listener.AddRoute(routes); } // See https://github.com/dapr/docs/blob/master/reference/api/pubsub_api.md#provide-a-route-for-dapr-to-discover-topic-subscriptions routes.MapGet("dapr/subscribe", this.GetTopicsAsync); app.UseRouter(routes.Build()); }) .Build(); this.log.LogInformation($"Starting Dapr HTTP listener on {this.appAddress} with {this.listeners.Count} function listener(s) registered."); await this.host.StartAsync(cancellationToken); this.log.LogInformation("Dapr HTTP host started successfully."); } }
public void Configure( IApplicationBuilder app, IHostingEnvironment env, LifetimeManager lifetimeManager, InterpreterManager interpreterManager, SecurityManager securityManager ) { lifetimeManager.Initialize(); interpreterManager.Initialize(); app.UseWebSockets(new WebSocketOptions { ReplaceFeature = true, KeepAliveInterval = TimeSpan.FromMilliseconds(1000000000), ReceiveBufferSize = 0x10000 }); var routeBuilder = new RouteBuilder(app, new RouteHandler(RemoteUriHelper.HandlerAsync)); routeBuilder.MapRoute("help_and_shiny", "remoteuri"); app.UseRouter(routeBuilder.Build()); app.UseBasicAuthentication(options => { options.Events = new BasicEvents { OnSignIn = securityManager.SignInAsync }; }); app.Use((context, next) => { if (!context.User.Identity.IsAuthenticated) { return context.Authentication.ChallengeAsync(); } else { return next(); } }); app.UseMvc(); }
public void Action_RouteValueInvalidation_DoesNotAffectActionAndController_ActionPassedInRouteValues() { // Arrage var services = GetServices(); var routeBuilder = new RouteBuilder() { DefaultHandler = new PassThroughRouter(), ServiceProvider = services, }; routeBuilder.MapRoute( "default", "{first}/{controller}/{action}", new { second = "default", controller = "default", action = "default" }); var actionContext = services.GetService <IActionContextAccessor>().ActionContext; actionContext.RouteData.Values.Add("first", "a"); actionContext.RouteData.Values.Add("controller", "Store"); actionContext.RouteData.Values.Add("action", "Buy"); actionContext.RouteData.Routers.Add(routeBuilder.Build()); var urlHelper = CreateUrlHelper(services); // Act // // In this test the 'first' route value has changed, meaning that *normally* the // 'controller' value could not be used. However 'controller' and 'action' are treated // specially by UrlHelper. var url = urlHelper.Action(action: null, values: new { first = "b", action = "Checkout" }); // Assert Assert.NotNull(url); Assert.Equal("/b/Store/Checkout", url); }
public void Configure(IApplicationBuilder app) { var routeBuilder = new RouteBuilder(app) .MapMiddlewarePost("/{id}", x => x.UseMiddleware <JsonMiddleware>()); app.UseRouter(routeBuilder.Build()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseRouting(); app.UseSession(); app.UseAuthentication(); // подключение аутентификации app.UseAuthorization(); var myRouteHandler = new RouteHandler(Handler); var routeBuilder = new RouteBuilder(app, myRouteHandler); routeBuilder.MapRoute("default", "Home/Index/NextPage"); app.UseRouter(routeBuilder.Build()); app.UseEndpoints(endpoints => { endpoints.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); }); }
private static void PrepareApplicationAndRouting() { var applicationBuilder = new ApplicationBuilderMock(routingServiceProvider); 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); } AdditionalRouting?.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(serviceProvider)); } router = routeBuilder.Build(); }
public void ConfigureModules(IRouter moMatchRouteHandler) { OnSetupModule((moduleOptions) => { // TODO: visitor design pattern might be better suite here.. if (moduleOptions.Module is ISharedModule sharedModule) { // Modules adds services to tenant level container. moduleOptions.HasSharedServices((moduleServices) => { sharedModule.ConfigureServices(moduleServices); }); // Module adds middleware to tenant level pipeline. moduleOptions.HasMiddlewareConfiguration((appBuilder) => { sharedModule.ConfigureMiddleware(appBuilder); }); } // We allow IRoutedModules to partipate in configuring their own isolated services, associated with their router if (moduleOptions.Module is IRoutedModule routedModule) { // Module has its own container, that is associated with certain routes. moduleOptions.HasRoutedContainer((moduleAppBuilder) => { var moduleRouteBuilder = new RouteBuilder(moduleAppBuilder, moMatchRouteHandler); routedModule.ConfigureRoutes(moduleRouteBuilder); var moduleRouter = moduleRouteBuilder.Build(); return(moduleRouter); }, moduleServices => routedModule.ConfigureServices(moduleServices)); } }); }
/// <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 { DefaultHandler = new MvcRouteHandler(), ServiceProvider = app.ApplicationServices }; 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())); }
public void Configure(IApplicationBuilder app) { var routeBuilder = new RouteBuilder(app); routeBuilder.MapRoute("Test/{action}/{id}", async context => { await context.Response.WriteAsync("Test/{action}/{id} template used."); }); routeBuilder.MapRoute("{controller=Courses}/{action=GetCourses}/{id?}", async context => { await context.Response.WriteAsync("Couses/GetCouses template is used"); }); routeBuilder.MapRoute("{controller=Home}/{action}/{id}", async context => { await context.Response.WriteAsync("{controller}/{action}/{id} template used."); }); app.UseRouter(routeBuilder.Build()); app.Run(async(context) => { await context.Response.WriteAsync("Default page."); }); }
public void Configure(IApplicationBuilder app) { var rootBuilder = new RouteBuilder(app); rootBuilder.MapGet("", (context) => { context.Response.Headers.Add("Content-Type", "text/html; charset=utf-8"); return(context.Response.WriteAsync($"<h1><p style='color:orange'>Hoşgeldin Sahip</p></h1><i>Bugün nasılsın?</i>")); } ); rootBuilder.MapGet("green/mile", (context) => { var routeData = context.GetRouteData(); context.Response.Headers.Add("Content-Type", "text/html; charset=utf-8"); return(context.Response.WriteAsync($"Vayyy <b>Gizli yolu</b> buldun!<br/>Tebrikler.")); } ); /*rootBuilder.MapGet("{*urlPath}", (context) => * { * var routeData = context.GetRouteData(); * return context.Response.WriteAsync($"Path bilgisi : {string.Join(",", routeData.Values)}"); * } * );*/ rootBuilder.MapGet("whatyouwant/{wanted=1 Bitcoin please}", (context) => { var values = context.GetRouteData().Values; context.Response.Headers.Add("Content-Type", "text/html; charset=utf-8"); return(context.Response.WriteAsync($"İstediğin şey bu.<h2>{values["wanted"]}</h2>OLDU BİL :)")); }); app.UseRouter(rootBuilder.Build()); }
public void assign_the_handler_type_and_method() { var route = RouteBuilder.Build <SomeEndpoint>(x => x.post_go()); route.HandlerType.ShouldBe(typeof(SomeEndpoint)); route.Method.Name.ShouldBe("post_go"); }
public void Configure(IApplicationBuilder app) { var routeBuilder = new RouteBuilder(app); routeBuilder.MapRoute("{controller}/{action}", async context => { context.Response.ContentType = "text/html;charset=utf-8"; await context.Response.WriteAsync("двухсегментный запрос"); }); routeBuilder.MapRoute("{controller}/{action}/{id}", async context => { context.Response.ContentType = "text/html;charset=utf-8"; await context.Response.WriteAsync("трехсегментный запрос"); }); app.UseRouter(routeBuilder.Build()); app.Run(async(context) => { await context.Response.WriteAsync("Hello World!"); }); }
public void serviceendpoint() { RouteBuilder.Build <ServiceEndpoint>(x => x.Index()).MethodAndPatternShouldBe("GET", ""); RouteBuilder.Build <ServiceEndpoint>(x => x.Get()).MethodAndPatternShouldBe("GET", ""); RouteBuilder.Build <ServiceEndpoint>(x => x.Put()).MethodAndPatternShouldBe("PUT", ""); RouteBuilder.Build <ServiceEndpoint>(x => x.Delete()).MethodAndPatternShouldBe("DELETE", ""); }
public static void Use(IApplicationBuilder app) { var routeBuilder = new RouteBuilder(app); routeBuilder.MapGet("/", context => { return(context.Response.WriteAsync("pong 4")); }); app.UseRouter(routeBuilder.Build()); app.UseHealthChecks("/healthz", new HealthCheckOptions() { ResponseWriter = async(context, report) => { var result = JsonConvert.SerializeObject( new { statusApplication = report.Status.ToString(), healthChecks = report.Entries.Select(e => new { check = e.Key, ErrorMessage = e.Value.Exception?.Message, status = Enum.GetName(typeof(HealthStatus), e.Value.Status) }) }); context.Response.ContentType = MediaTypeNames.Application.Json; await context.Response.WriteAsync(result); } }); }
//使用自定义路由 private void UseMyRoute(IApplicationBuilder app) { var trackPkgRouteHandler = new RouteHandler(context => { var routeValues = context.GetRouteData().Values; return(context.Response.WriteAsync($"Hello! Route values:{string.Join(", ", routeValues)}")); }); var routeBuilder = new RouteBuilder(app, trackPkgRouteHandler); // routeBuilder.MapRoute( "Track Package Route", "package/{operation:regex(^(track|create|detonate)$)}/{id:int}" ); // routeBuilder.MapGet("hello/{name}", context => { var values = context.GetRouteData().Values; return(context.Response.WriteAsync($"Hi, {values["name"]}!")); }); //build var routes = routeBuilder.Build(); app.UseRouter(routes); // // URLGenerationTest(app,routes); }
/// <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 = app.ApplicationServices.GetRequiredService<MvcRouteHandler>(), }; configureRoutes(routes); routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices)); return app.UseRouter(routes.Build()); }
public static IApplicationBuilder UseDD4T(this IApplicationBuilder app, Action <IRouteBuilder> configureRoutes = null) { var dd4tRoute = new RouteBuilder(app, app.ApplicationServices.GetRequiredService <MvcRouteHandler>()); //If additional routes are configured, add them as well if (configureRoutes != null) { configureRoutes.Invoke(dd4tRoute); } dd4tRoute.MapRoute(name: "areaRoute", template: "{area:exists}/{controller}/{action}", defaults: new { controller = "AwesomeController", action = "DoIt" }); //Always map the default route and apply the favicon ignore constaint dd4tRoute.MapRoute( "DefaultPage", "{*page}", new { controller = "Page", action = "Index" } ); //dd4tRoute.MapRoute( // name: "TridionPage", // //template: "{*PageUrl:faviconIgnoreConstraint}", // template: "{*page}", // defaults: new { controller = "Page", action = "Index" } // action = "PageAsync" } // //defaults: new { controller = "ComponentPresentation", action = "CP" } // ); var routes = dd4tRoute.Build(); app.UseMiddleware <IgnoreFaviconMiddleware>(); app.UseMiddleware <DD4TMiddleWare>(routes); return(app); }
/// <summary> /// Extension methods for <see cref="IApplicationBuilder"/> to add Smt to the request execution pipeline. /// All config can be set in singleton SmtSettings.Instance. /// Dependence services: Routing /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/>.</param> /// <param name="applicationNamespace">the namespace of Startup class</param> /// <returns></returns> public static IApplicationBuilder UseSmt <ContextType, TenantEntityType, UserEntityType, UserClaimEntityType>( this IApplicationBuilder app, string applicationNamespace) where TenantEntityType : class, ITenant, new() where UserEntityType : class, IUser, new() where UserClaimEntityType : class, IUserClaim where ContextType : DbContext, IDbContext <TenantEntityType, UserEntityType, UserClaimEntityType> { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (string.IsNullOrEmpty(applicationNamespace)) { throw new ArgumentNullException(nameof(applicationNamespace)); } var entryAssembly = Assembly.Load(new AssemblyName(applicationNamespace)); var controllerNamespacePattern = string.Format("{0}.Controllers.{{0}}Controller, {1}", entryAssembly.FullName.Split(',')[0], entryAssembly.FullName); var smtRouter = new SmtRouter <ContextType, TenantEntityType, UserEntityType, UserClaimEntityType>(app, controllerNamespacePattern); var routeBuilder = new RouteBuilder(app, smtRouter.GetRouteHandler()); routeBuilder.MapRoute( name: "default", template: "{controller}/{action}"); return(app.UseRouter(routeBuilder.Build())); }
private static IRouter GetRouter( IServiceProvider services, string mockRouteName, string mockTemplateValue) { var routeBuilder = new RouteBuilder(); routeBuilder.ServiceProvider = services; var target = new Mock <IRouter>(MockBehavior.Strict); target .Setup(router => router.GetVirtualPath(It.IsAny <VirtualPathContext>())) .Callback <VirtualPathContext>(context => context.IsBound = true) .Returns <VirtualPathContext>(context => null); routeBuilder.DefaultHandler = target.Object; routeBuilder.MapRoute(string.Empty, "{controller}/{action}/{id}", new RouteValueDictionary(new { id = "defaultid" })); routeBuilder.MapRoute("namedroute", "named/{controller}/{action}/{id}", new RouteValueDictionary(new { id = "defaultid" })); var mockHttpRoute = new Mock <IRouter>(); mockHttpRoute .Setup(mock => mock.GetVirtualPath(It.Is <VirtualPathContext>(c => string.Equals(c.RouteName, mockRouteName)))) .Callback <VirtualPathContext>(c => c.IsBound = true) .Returns(new VirtualPathData(mockHttpRoute.Object, mockTemplateValue)); routeBuilder.Routes.Add(mockHttpRoute.Object); return(routeBuilder.Build()); }
public void get_route_pattern_with_querystring_parameters_when_there_are_no_values() { var route = RouteBuilder.Build(typeof(QueryStringTarget), "route"); route.CreateUrlFromInput(new QueryStringTarget()) .ShouldEqual("route"); }
public static IApplicationBuilder UseBotwin(this IApplicationBuilder builder, BotwinOptions options) { ApplyGlobalBeforeHook(builder, options); ApplyGlobalAfterHook(builder, options); var routeBuilder = new RouteBuilder(builder); //Invoke so ctors are called that adds routes to IRouter var srvs = builder.ApplicationServices.GetServices <BotwinModule>(); //Cache status code handlers var statusCodeHandlers = builder.ApplicationServices.GetServices <IStatusCodeHandler>(); foreach (var module in srvs) { foreach (var route in module.Routes) { Func <HttpRequest, HttpResponse, RouteData, Task> handler; handler = module.Before != null?CreateModuleBeforeHandler(module, route) : route.handler; if (module.After != null) { handler += module.After; } var finalHandler = CreateFinalHandler(handler, statusCodeHandlers); routeBuilder.MapVerb(route.verb, route.path, finalHandler); } } return(builder.UseRouter(routeBuilder.Build())); }
public static void BuildRoutes(IApplicationBuilder app) { var trackPackageRouteHandler = new RouteHandler(context => { var routeValues = context.GetRouteData().Values; return(context.Response.WriteAsync( $"Hello! Route values: {string.Join(", ", routeValues)}")); }); var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler); routeBuilder.MapRoute( "Track Package Route", "package/{operation:regex(^(track|create|detonate)$)}/{id:int}"); routeBuilder.MapGet("hello/{name}", context => { var name = context.GetRouteValue("name"); // This is the route handler when HTTP GET "hello/<anything>" matches // To match HTTP GET "hello/<anything>/<anything>, // use routeBuilder.MapGet("hello/{*name}" return(context.Response.WriteAsync($"Hi, {name}!")); }); routeBuilder.MapRoute( "ViewWorkshop", "{workshopCode}/", new { controller = "Workshop", action = "GetByCode" } ); var routes = routeBuilder.Build(); app.UseRouter(routes); }
public void route_with_relative_path() { var route = RouteBuilder.Build <SpreadHttpActions>(x => x.get_folder(null)); route.Pattern.ShouldBe("folder/..."); route.Segments.Last().ShouldBeOfType <Spread>(); }
public void route_with_path_segments() { var route = RouteBuilder.Build <SpreadHttpActions>(x => x.get_file(null)); route.Pattern.ShouldBe("file/..."); route.Segments.Last().ShouldBeOfType <Spread>(); }
/// <summary> /// Adds Botwin to the specified <see cref="IApplicationBuilder"/>. /// </summary> /// <param name="builder">The <see cref="IApplicationBuilder"/> to configure.</param> /// <param name="options">A <see cref="BotwinOptions"/> instance.</param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IApplicationBuilder UseBotwin(this IApplicationBuilder builder, BotwinOptions options) { ApplyGlobalBeforeHook(builder, options); ApplyGlobalAfterHook(builder, options); var routeBuilder = new RouteBuilder(builder); //Create a "startup scope" to resolve modules from using (var scope = builder.ApplicationServices.CreateScope()) { //Get all instances of BotwinModule to fetch and register declared routes foreach (var module in scope.ServiceProvider.GetServices <BotwinModule>()) { var moduleType = module.GetType(); var distinctPaths = module.Routes.Keys.Select(route => route.path).Distinct(); foreach (var path in distinctPaths) { routeBuilder.MapRoute(path, CreateRouteHandler(path, moduleType)); } } } return(builder.UseRouter(routeBuilder.Build())); }
public static IApplicationBuilder UseHighwayRestArea <TContext>(this IApplicationBuilder app, Action <RestAreaOptionsBuilder <TContext> > configure) where TContext : UnitOfWork { var contextOptions = app.ApplicationServices.GetService(typeof(DbContextOptions <TContext>)) as DbContextOptions <TContext>; var model = contextOptions.GetExtension <CoreOptionsExtension>().Model; var builder = new RestAreaOptionsBuilder <TContext>(model); configure(builder); var options = builder.Build(); var routeBuilder = new RouteBuilder(app, new RouteHandler(options.Handler)); foreach (var entity in options.Entities) { var root = options.UrlPrefix; CreateRoutes(routeBuilder, entity, root); } var routes = routeBuilder.Build(); app.UseRouter(routes); return(app); }
private static IWebHostBuilder BuildWebHost( Container container, ILogger logger, IConfiguration configuration, params string[] args) => WebHost .CreateDefaultBuilder(args) .ConfigureAppConfiguration(builder => { }) .ConfigureServices((context, services) => { services.AddRouting(); services.EnableSimpleInjectorCrossWiring(container); services.UseSimpleInjectorAspNetRequestScoping(container); services.AddSingleton(_ => container.GetAllInstances <IHostedService>()); services.AddSingleton <ILoggerFactory>(new SerilogLoggerFactory(logger)); }) .Configure(app => { container.AutoCrossWireAspNetComponents(app); container.Verify(); app.Use(async(context, next) => { TraceContext.Set(Guid.NewGuid().ToString(), null); await next.Invoke(); }); var router = new RouteBuilder(app); router.MapPost("orders", container.GetInstance <PlaceOrderRequestHandler>().Handle); router.MapGet("orders/{orderId}", container.GetInstance <GetOrderRequestHandler>().Handle); app.UseRouter(router.Build()); });
/// <summary> /// Runs the <see cref="TemplateRouteFetcher"/> with the specified route configuration. /// </summary> /// <param name="configure">Function to configure routes</param> /// <returns>List of routes returned from the route fetcher</returns> private static IList <RouteInfo> RunFetcher(Action <RouteBuilder> configure) { var serviceProvider = new Mock <IServiceProvider>(); serviceProvider.Setup(x => x.GetService(typeof(RoutingMarkerService))) .Returns(new Mock <RoutingMarkerService>().Object); serviceProvider.Setup(x => x.GetService(typeof(IInlineConstraintResolver))) .Returns(new Mock <IInlineConstraintResolver>().Object); var appBuilder = new Mock <IApplicationBuilder>(); appBuilder.Setup(x => x.ApplicationServices).Returns(serviceProvider.Object); var routes = new RouteBuilder(appBuilder.Object) { DefaultHandler = new Mock <IRouter>().Object }; configure(routes); var router = routes.Build(); var routeData = new RouteData(); routeData.Routers.Add(router); var fetcher = new TemplateRouteFetcher(new Mock <IConstraintsProcessor>().Object, new RouteTemplateParser()); return(fetcher.GetRoutes(routeData).ToList()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, IOptions <RequestLocalizationOptions> localizationOptions) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } app.UseHttpsRedirection(); app.UseRequestLocalization(localizationOptions.Value); app.UseStaticFiles(); app.UseCookiePolicy(); app.UseMvc(routes => { }); var routeBuilder = new RouteBuilder(app); if (AlwaysIncludeCultureInUrl) { routeBuilder.RedirectCulturelessToDefaultCulture(localizationOptions.Value); } app.UseRouter(routeBuilder.Build()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseCors("AllowAll"); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseDefaultFiles(); app.UseMvc(); var routeBuilder = new RouteBuilder(app); routeBuilder.MapRoute("{controller}/{action}", async context => { context.Response.ContentType = "text/html; charset=utf-8"; }); routeBuilder.MapRoute("{controller}/{action}/{id}", async context => { context.Response.ContentType = "text/html; charset=utf-8"; }); app.UseRouter(routeBuilder.Build()); }
public void Configure(IApplicationBuilder app) { var routeBuilder = new RouteBuilder(app); routeBuilder.ConfigureWardeinRouting(); app.UseRouter(routeBuilder.Build()); }
public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseHsts(); } app.UseHttpsRedirection(); app.UseMvc(); var myRouteHandler = new RouteHandler(Handle); var routeBuilder = new RouteBuilder(app, myRouteHandler); routeBuilder.MapRoute("default", "{controller}/{action}"); app.UseRouter(routeBuilder.Build()); app.Run(async(context) => { await context.Response.WriteAsync("Hello World!"); }); }
public void Configure(IApplicationBuilder app) { app.UseCors(policy => policy .AllowAnyHeader() .AllowAnyMethod() .AllowAnyOrigin() .AllowCredentials() ); var builder = new RouteBuilder(app); ((HttpCommandRouteMapper)app.ApplicationServices.GetService(typeof(HttpCommandRouteMapper))).Map(builder); ((HttpQueryRouteMapper)app.ApplicationServices.GetService(typeof(HttpQueryRouteMapper))).Map(builder); app.UseRouter(builder.Build()); }
/// <summary> /// /// </summary> /// <param name="app"></param> /// <param name="rpcConfig"></param> public static void Initialize(IApplicationBuilder app, RpcConfig rpcConfig) { RpcManager.Initialize(rpcConfig); if (rpcConfig?.Service?.Paths == null) return; if (app == null) return; var routers = new RouteBuilder(app); foreach (var path in rpcConfig.Service.Paths) { routers.MapRoute(path + "{*RpcLiteServicePath}", context => RpcManager.ProcessAsync(new AspNetCoreServerContext(context))); } var routes1 = routers.Build(); app.UseRouter(routes1); }
// Routes must configured in Configure public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory) { var trackPackageRouteHandler = new RouteHandler(context => { var routeValues = context.GetRouteData().Values; return context.Response.WriteAsync( $"Hello! Route values: {string.Join(", ", routeValues)}"); }); var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler); routeBuilder.MapRoute( "Track Package Route", "package/{operation:regex(track|create|detonate)}/{id:int}"); routeBuilder.MapGet("hello/{name}", context => { var name = context.GetRouteValue("name"); // This is the route handler when HTTP GET "hello/<anything>" matches // To match HTTP GET "hello/<anything>/<anything>, // use routeBuilder.MapGet("hello/{*name}" return context.Response.WriteAsync($"Hi, {name}!"); }); var routes = routeBuilder.Build(); app.UseRouter(routes); // Show link generation when no routes match. app.Run(async (context) => { var dictionary = new RouteValueDictionary { { "operation", "create" }, { "id", 123} }; var vpc = new VirtualPathContext(context, null, dictionary, "Track Package Route"); var path = routes.GetVirtualPath(vpc).VirtualPath; context.Response.ContentType = "text/html"; await context.Response.WriteAsync("Menu<hr/>"); await context.Response.WriteAsync($"<a href='{path}'>Create Package 123</a><br/>"); }); // End of app.Run }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory) { loggerFactory.AddConsole(minLevel: LogLevel.Trace); var defaultHandler = new RouteHandler((c) => c.Response.WriteAsync($"Hello world! Route values: " + $"{string.Join(", ", c.GetRouteData().Values)}") ); var routeBuilder = new RouteBuilder(app, defaultHandler); routeBuilder.AddHelloRoute(app); routeBuilder.MapRoute( "Track Package Route", "package/{operation:regex(track|create|detonate)}/{id:int}"); app.UseRouter(routeBuilder.Build()); // demonstrate link generation var trackingRouteCollection = new RouteCollection(); trackingRouteCollection.Add(routeBuilder.Routes[1]); // "Track Package Route" app.Run(async (context) => { var dictionary = new RouteValueDictionary { {"operation","create" }, {"id",123} }; var vpc = new VirtualPathContext(context, null, dictionary, "Track Package Route"); context.Response.ContentType = "text/html"; await context.Response.WriteAsync("Menu<hr/>"); await context.Response.WriteAsync(@"<a href='" + trackingRouteCollection.GetVirtualPath(vpc).VirtualPath + "'>Create Package 123</a><br/>"); }); }
private static void PrepareApplicationAndRouting(StartupMethods startupMethods) { var applicationBuilder = new ApplicationBuilderMock(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); } AdditionalRouting?.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(serviceProvider)); } router = routeBuilder.Build(); }