C# IApplicationBuilder.Map方法代码示例

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            app.UseWebSockets();
            app.UseDefaultFiles();
            app.UseStaticFiles();

            app.Map("/Preview/Socket", PreviewSocketHandler.Map);
            app.Map("/Index/Socket", DashboardSocketHandler.Map);
            app.Map("/SACNTransmitters/Socket", SACNTransmitterLive.Map);
            app.Map("/OSCListeners/Socket", OSCListenerLive.Map);
            app.Map("/RawDMX/Socket", RawDMXSocketHandler.Map);

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }

        public void Configure(IApplicationBuilder app)
        {
            var settings = app.ApplicationServices.GetService<IOptions<AppSettings>>();

            LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());

            app.Map("/core", core =>
            {
                var factory = InMemoryFactory.Create(
                                        users: Users.Get(),
                                        clients: Clients.Get(),
                                        scopes: Scopes.Get());

                var cors = new DefaultCorsPolicyService
                {
                    AllowAll = true
                };
                factory.CorsPolicyService = new Registration<ICorsPolicyService>(cors);

                var idsrvOptions = new IdentityServerOptions
                {
                    LoggingOptions = new LoggingOptions
                    {
                        IncludeSensitiveDataInLogs = true,
                        //WebApiDiagnosticsIsVerbose = true,
                        //EnableWebApiDiagnostics = true
                    },
                    IssuerUri = settings.Options.IssuerUrl,
                    SiteName = settings.Options.SiteTitle,
                    Factory = factory,
                    SigningCertificate = Certificate.Get(),
                    RequireSsl = false,
                    AuthenticationOptions = new AuthenticationOptions
                    {

                    }
                };

                core.UseIdentityServer(idsrvOptions);
            });

            app.Map("/api", api =>
            {
                api.UseOAuthBearerAuthentication(options => {
                    options.Authority = settings.Options.AuthorizationUrl;
                    options.MetadataAddress = settings.Options.AuthorizationUrl + "/.well-known/openid-configuration";
                    options.TokenValidationParameters.ValidAudience = settings.Options.BaseUrl + "/resources";
                });

                // for web api
                api.UseMvc();
            });
        }

        public void Configure(IApplicationBuilder app)
        {
            app.Map("/echo", config => config.Run(async context =>
            {
                var path = context.Request.Path.ToString();
                await context.Response.WriteAsync(path);
            }));

            app.Map("/upper", config => config.Run(async context =>
            {
                var path = context.Request.Path.ToString().ToUpper();
                await context.Response.WriteAsync(path);
            }));
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            //
            // Scenarios:
            // 1. Multiple services.
            // 2. Various versions or kinds of clients side by side.
            //

            //
            // SMS
            //
            app.Map("/sms",
                subApp =>
                {
                    subApp.RunGateway(new GatewayOptions() { ServiceDescription = new SmsServiceDescription() });
                }
            );

            //
            // Counter
            //
            app.Map("/counter",
                subApp =>
                {
                    subApp.RunGateway(new GatewayOptions() { ServiceDescription = new CounterServiceDescription() });
                }
            );

            app.Map("/Hosting/CounterService",
                subApp =>
                {
                    subApp.RunGateway(new GatewayOptions() { ServiceDescription = new CounterServiceDescription() });
                }
            );

            app.MapWhen(
                context =>
                {
                    StringValues serviceNames;

                    return context.Request.Headers.TryGetValue("SF-ServiceName", out serviceNames) &&
                           serviceNames.Count == 1 &&
                           serviceNames[0] == "fabric:/Hosting/CounterService";
                },
                subApp =>
                {
                    subApp.RunGateway(new GatewayOptions() { ServiceDescription = new CounterServiceDescription() });
                }
            );
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            // Configuration
            var builder = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

            builder.AddEnvironmentVariables();
            builder.Build();

            // Logging
            loggerFactory.AddDebug(minLevel: LogLevel.Verbose);
            
            // Using different environments
            if (string.Equals(env.EnvironmentName, "Development", StringComparison.OrdinalIgnoreCase)) { }

            // Middlewares
            app.UseDeveloperExceptionPage();
            app.UseRuntimeInfoPage(); // default path is /runtimeinfo            
            app.UseDefaultFiles();
            app.UseStaticFiles();

            // Web sockets
            app.Map("/Managed", (appBuilder) => WebSocketsHelper.Configure(appBuilder, loggerFactory));

            // IIS
            app.UseIISPlatformHandler();
        }

		public void Configure(IApplicationBuilder app)
		{
			app.UseMvc();

			app.Map("/site", siteApp =>
			{
				siteApp.UseFileServer(new FileServerOptions
				{
					FileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot")),
					EnableDirectoryBrowsing = true
				});
			});

			app.Use(async (context, next) =>
			{
				await context.Response.WriteAsync("=== BEFORE ===");
				await next();
				await context.Response.WriteAsync("=== AFTER ===");
			});

			app.Run(async (context) =>
			{
				Console.WriteLine($"Got request for {context.Request.Path}");

				await context.Response.WriteAsync(
					[email protected]"<!DOCTYPE 'html'><html><body><h1>Hello from {
						context.Request.Path }!</h1></body></html>");
			});
		}

        public void Configure(IApplicationBuilder app, IApplicationEnvironment env)
        {
            var certFile = env.ApplicationBasePath + "\\idsrv3test.pfx";

            app.Map("/core", core =>
            {
                var factory = InMemoryFactory.Create(

                                clients: Clients.Get(),
                                scopes: Scopes.Get());

                var userService = new UserService();
                factory.UserService = new Registration<IUserService>(resolver => userService);
                // factory.ViewService = new Registration<IViewService>(typeof(CustomViewService));

                var idsrvOptions = new IdentityServerOptions
                {
                    IssuerUri = "",
                    Factory = factory,
                    RequireSsl = false,
                    LoggingOptions =
                    // SigningCertificate = new X509Certificate2(certFile, "idsrv3test")
                };

                core.UseIdentityServer(idsrvOptions);
            });

        public void Configure(IApplicationBuilder app, IApplicationEnvironment env)
        {
            app.UseIISPlatformHandler();
            app.UseDeveloperExceptionPage();

            var certFile = env.ApplicationBasePath + "\\idsrv3test.pfx";

            app.Map("/identity", idsrvApp =>
            {
                idsrvApp.UseIdentityServer(new IdentityServerOptions
                {
                    SiteName = "Embedded IdentityServer",
                    SigningCertificate = new X509Certificate2(certFile, "idsrv3test"),

                    Factory = new IdentityServerServiceFactory()
                                .UseInMemoryUsers(Users.Get())
                                .UseInMemoryClients(Clients.Get())
                                .UseInMemoryScopes(Scopes.Get()),

                    AuthenticationOptions = new IdentityServer3.Core.Configuration.AuthenticationOptions
                    {
                        EnableLocalLogin = false,
                        IdentityProviders = ConfigureIdentityProviders,
                        SignInMessageThreshold = 5
                    }
                });
            });

            app.UseCors("mypolicy");
            app.UseMvc();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            loggerFactory.AddConsole(LogLevel.Debug);
			
            app.Map(
                new PathString("/onboarding"),
                branch => branch.Run(async ctx =>
                {
                    await ctx.Response.WriteAsync("Onboarding");
                })
            );

            app.UseMultitenancy<AppTenant>();

            app.Use(async (ctx, next) =>
            {
                if (ctx.GetTenant<AppTenant>().Name == "Default")
                {
                    ctx.Response.Redirect("/onboarding");
                } else
                {
                    await next();
                }
            });

            app.UseMiddleware<LogTenantMiddleware>();
        }

        public void Configure(IApplicationBuilder app)
        {
            app.UseMiddleware<RequestDurationMiddleware>();

            app.Use(async (context, next) =>
            {
                await context.Response.WriteAsync("Hi Cancel!<br/>");
                await next.Invoke();
                await context.Response.WriteAsync("<br/>I'm done.");
            });

            app.Map("/diagnostics", c =>
            {
                c.Run(async ctx =>
               {
                   var feature = ctx.GetFeature<IHttpConnectionFeature>();
                   await ctx.Response.WriteAsync("Hello Diagnostics test from " +  feature.RemoteIpAddress);
               });
            });

            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        }

        public void Configure(IApplicationBuilder app)
        {

            //app.Map("", (a) =>
            //{
            //    a.UseWebSockets(new WebSocketOptions() { ReplaceFeature = true });
            //    a.Use<IWebSocketHandler>(async (context, next, handler) =>
            //    {
            //        if (!context.IsWebSocketRequest)
            //        {
            //            await next();
            //            return;
            //        }

            //        await handler.MessageLoopAsync();
            //    });
            //});

            app.Map("", (a) =>
            {
                a.UseWebSockets(new WebSocketOptions() { ReplaceFeature = true });
                a.Use(async (context, next) =>
                {
                    if (!context.IsWebSocketRequest)
                    {
                        await next();
                        return;
                    }

                    var factory = a.ApplicationServices.GetService<SessionFactory>();
                    var handler = new SessionHandler(context, factory);
                    await handler.MessageLoopAsync();
                });
            });
        }

        // Configure is called after ConfigureServices is called.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            if(env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            
            loggerFactory
                .AddConsole(Configuration.GetSection("Logging"))
                .AddDebug();
            
            // Use the Default files ['index.html', 'index.htm', 'default.html', 'default.htm']
            app.UseDefaultFiles()
                .UseStaticFiles()
                .UseIISPlatformHandler()
                .UseMvc();

            // Setup a generic Quotes API EndPoint
            app.Map("/api/quotes", (config) =>
            {
                app.Run(async context =>
                {
                    var quotes = "{ \"quotes\":" +
                                 " [ { \"quote\": \"Duct tape is like the force. It has a light side, a dark side, and it holds the universe together.\", \"author\":\"Oprah Winfrey\"} ]" +
                                 "}";
                    context.Response.ContentLength = quotes.Length;
                    context.Response.ContentType = "application/json";                    
                    await context.Response.WriteAsync(quotes);
                });
            });
        }

        public void Configure(IApplicationBuilder app)
        {
            app.UseSession();

            app.Map("/session", subApp =>
            {
                subApp.Run(async context =>
                {
                    int visits = 0;
                    visits = context.Session.GetInt32("visits") ?? 0;
                    context.Session.SetInt32("visits", ++visits);
                    await context.Response.WriteAsync("Counting: You have visited our page this many times: " + visits);
                });
            });

            app.Run(async context =>
            {
                int visits = 0;
                visits = context.Session.GetInt32("visits") ?? 0;
                await context.Response.WriteAsync("<html><body>");
                if (visits == 0)
                {
                    await context.Response.WriteAsync("Your session has not been established.<br>");
                    await context.Response.WriteAsync(DateTime.Now + "<br>");
                    await context.Response.WriteAsync("<a href=\"/session\">Establish session</a>.<br>");
                }
                else
                {
                    context.Session.SetInt32("visits", ++visits);
                    await context.Response.WriteAsync("Your session was located, you've visited the site this many times: " + visits);
                }
                await context.Response.WriteAsync("</body></html>");
            });
        }

        public void Configure(IApplicationBuilder app, IApplicationLifetime lifetime, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            app.Map("/simplewebapi", (app1) => this.ConfigureIIS(app1, lifetime, env, loggerFactory));

            app.UseMvc();

            app.UseWelcomePage();
        }

        private void MockAuthorizationPipeline_OnPostConfigure(IApplicationBuilder app)
        {
            app.Map(Constants.RoutePaths.Login.EnsureLeadingSlash(), path =>
            {
                path.Run(ctx => Login(ctx));
            });

            app.Map(Constants.RoutePaths.Consent.EnsureLeadingSlash(), path =>
            {
                path.Run(ctx => Consent(ctx));
            });

            app.Map(Constants.RoutePaths.Error.EnsureLeadingSlash(), path =>
            {
                path.Run(ctx => Error(ctx));
            });
        }