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