C# IServiceProvider.GetServices方法代码示例

        public async Task Invoke(HttpContext context, IServiceProvider serviceProvider)
        {
            #region IRunOnEachRequest
            var befores = serviceProvider.GetServices<IRunOnEachRequest>();
            foreach (var cmd in befores)
            {
                cmd.Execute();
            }
            #endregion

            #region IRunOnEachResponse
            Func<object, Task> iRunOnResponseStarted = ctx => RunWhenReponseStarts(serviceProvider);
            context.Response.OnStarting(iRunOnResponseStarted, context);
            #endregion

            #region IRunAfterEachResponse
            Func<object, Task> iRunOnResponseCompleted = ctx => RunWhenReponseCompletes(serviceProvider);
            context.Response.OnCompleted(iRunOnResponseCompleted, context);
            #endregion

            try
            {
                await next(context);
            }
            catch (Exception ex)
            {
                #region IRunOnError
                var errorCmds = serviceProvider.GetServices<IRunOnError>();
                foreach (var cmd in befores)
                {
                    cmd.Execute();
                }
                #endregion

                throw;
            }
            #region IRunAfterEachRequest
            var afters = serviceProvider.GetServices<IRunAfterEachRequest>();
            foreach (var cmd in afters)
            {
                cmd.Execute();
            }
            #endregion
        }

        // Build the middleware pipeline for the current tenant
        public RequestDelegate BuildTenantPipeline(ShellSettings shellSettings, IServiceProvider serviceProvider)
        {
            var startups = serviceProvider.GetServices<IStartup>();
            var inlineConstraintResolver = serviceProvider.GetService<IInlineConstraintResolver>();

            IApplicationBuilder appBuilder = new ApplicationBuilder(serviceProvider);

            string routePrefix = "";
            if (!string.IsNullOrWhiteSpace(shellSettings.RequestUrlPrefix))
            {
                routePrefix = shellSettings.RequestUrlPrefix + "/";
            }

            var routeBuilder = new RouteBuilder(appBuilder)
            {
                DefaultHandler = serviceProvider.GetRequiredService<MvcRouteHandler>()
            };

            var prefixedRouteBuilder = new PrefixedRouteBuilder(routePrefix, routeBuilder, inlineConstraintResolver);

            // Register one top level TenantRoute per tenant. Each instance contains all the routes
            // for this tenant.

            // In the case of several tenants, they will all be checked by ShellSettings. To optimize
            // the TenantRoute resolution we can create a single Router type that would index the
            // TenantRoute object by their ShellSetting. This way there would just be one lookup.
            // And the ShellSettings test in TenantRoute would also be useless.

            foreach (var startup in startups)
            {
                startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider);
            }


            // The default route is added to each tenant as a template route, with a prefix
            prefixedRouteBuilder.Routes.Add(new Route(
                prefixedRouteBuilder.DefaultHandler,
                "Default",
                "{area:exists}/{controller}/{action}/{id?}",
                null,
                null,
                null,
                inlineConstraintResolver)
            );

            // Add home page route
            routeBuilder.Routes.Add(new HomePageRoute(shellSettings.RequestUrlPrefix, routeBuilder, inlineConstraintResolver));

            var router = prefixedRouteBuilder.Build();

            appBuilder.UseRouter(router);

            var pipeline = appBuilder.Build();

            return pipeline;
        }

    // 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, IServiceProvider provider)
    {
      loggerFactory.AddConsole(this.Configuration.GetSection("Logging"));
      loggerFactory.AddDebug();

      app.UseIISPlatformHandler();

      app.UseStaticFiles();

      app.UseMvc();

      // activate interactors
      foreach(var interactor in provider.GetServices<IInteractor>())
      {
        interactor.Activate();
      }
    }

 private static void StartUp(IServiceProvider serviceProvider)
 {
     var starts = serviceProvider.GetServices<IRunAtStartup>();
     foreach (var cmd in starts)
     {
         cmd.Execute();
     }
 }

 private static void Init(IServiceProvider serviceProvider)
 {
     var inits = serviceProvider.GetServices<IRunAtInit>();
     foreach (var cmd in inits)
     {
         cmd.Execute();
     }
 }

 public ServiceResolver(IServiceProvider provider)
 {
     _Services = provider.GetServices();
 }