C# Container.RegisterWebApiControllers方法代码示例

        // Invoked once at startup to configure your application.
        public void Configuration(IAppBuilder builder)
        {
            var config = new HttpConfiguration();

            // Create the container as usual.
            var container = new Container();

            // Register your types, for instance using the RegisterWebApiRequest
            // extension from the integration package:
            container.RegisterWebApiRequest<IUserRepository, SqlUserRepository>();

            // This is an extension method from the integration package.
            container.RegisterWebApiControllers(config);

            container.Verify();

            config.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);

            config.MapHttpAttributeRoutes();
            //config.Routes.MapHttpRoute("Default", "", new { controller = "OEmbed" });

            //config.Formatters.XmlFormatter.UseXmlSerializer = true;
            //config.Formatters.Remove(config.Formatters.JsonFormatter);
            ////config.Formatters.Remove(config.Formatters.XmlFormatter);
            // config.Formatters.JsonFormatter.UseDataContractJsonSerializer = true;
            builder.UseWebApi(config);

            //builder.Use(async (context, next) => {
            //    using (container.BeginExecutionContextScope())
            //    {
            //        await next();
            //    }
            //});
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            var container = new Container();

            container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();

            container.Register<LocalityContext>();
            container.Register(typeof(IRepository<>), typeof(Repository<>) );
            container.Register<IUserService, UserService>();
            container.Register<IEventService, EventService>();
            container.Register<ITicketService, TicketService>();
            container.Register<IPaymentService, PaymentService>();

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);

            GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None;
        }

        public static Container RegisterComponents()
        {
            // Set up the localdb data directory.
            var dataDirectory = (string)AppDomain.CurrentDomain.GetData("DataDirectory");
            dataDirectory = Path.Combine(dataDirectory, "..\\..\\Database");
            dataDirectory = Path.GetFullPath(dataDirectory);
            AppDomain.CurrentDomain.SetData("DataDirectory", dataDirectory);

            // Create the container and register all the api controllers.
            var container = new Container();
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            // Model.Api Registrations
            container.Register<IAuthenticationService, AuthenticationService>();
            container.Register<IChannelService, ChannelService>();
            container.Register<IUserItemService, UserItemService>();
            container.Register<IRegistrationService, RegistrationService>();

            // Model.Persistence Registations
            container.Register(
                () => new SqlHelper(ConfigurationManager.AppSettings["persistence"]),
                Lifestyle.Singleton);
            container.Register<IRssService, RssService>();
            container.Register<IUserService, UserService>();

            // Verify that everything is wired up properly.
            container.Verify();

            // Register the container as the default dependency resolver.
            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);

            return container;
        }

        public static void Initialize()
        {
            var container = new Container();
            container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();

            InitializeContainer(container);

            container.RegisterPerWebRequest(() =>
            {
                if (HttpContext.Current != null && HttpContext.Current.Items["owin.Enviroment"] == null && container.IsVerifying)
                {
                    return new OwinContext().Authentication;
                }

                return HttpContext.Current.GetOwinContext().Authentication;
            });

            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            container.Verify();

            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
        }

        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.EnableCors(new MyCorsPolicyProvider());

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            var container = new Container();

            ModelDI.Confiure(container);

            ServicesDI.Confiure(container);

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);
        }

        public static void Register(Container container)
        {
            container.Register(typeof (IQueryHandler<,>), new[] {typeof (IQueryHandler<,>).Assembly});
            container.Register(typeof (ICommandHandler<,>), new[] {typeof (ICommandHandler<,>).Assembly});

            container.RegisterCollection(typeof (IHyperMediaState), typeof (IHyperMediaState).Assembly);
            container.Register<IBoardState, BoardState>();
            container.Register<IBoardTaskState, BoardTaskState>();
            container.Register<IBoardColumnState, BoardColumnState>();

            container.Register<ISlugService, SlugService>();

            container.Register<ICommandDispatcher, CommandDispatcher>();
            container.Register<IQueryDispatcher, QueryDispatcher>();
            container.Register<ILinkFactory, LinkFactory>();
            container.Register<IHyperMediaFactory, HyperMediaFactory>();
            container.Register<IMappingService, MappingService>();

            container.RegisterWebApiRequest<IDataContext, DataContext>();

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.EnableHttpRequestMessageTracking(GlobalConfiguration.Configuration);
            container.RegisterSingleton<IRequestMessageProvider>(new RequestMessageProvider(container));

            container.Register<IValidator<Board>, BoardValidator>();
            container.Register<IValidator<BoardColumn>, BoardColumnValidator>();
            container.Register<IValidator<BoardTask>, BoardTaskValidator>();

            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            var container = new Container();

            // Here comes container registrations
            #region Project-dependent injections
            container.RegisterWebApiRequest<IApplicationDbContext, ApplicationDbContext>();
            container.RegisterWebApiRequest<ApplicationDbContext>();

            container.RegisterWebApiRequest<IProductsService, ProductsService>();
            container.RegisterWebApiRequest<ICrudRepository<Product>, CrudRepository<Product>>();
            #endregion

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);
        }

        public static void Register(HttpConfiguration config)
        {
            using (var container = new Container())
            {
                container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();

                // Chamada dos módulos do Simple Injector
                BootStrapper.RegisterServices(container);

                // Necessário para registrar o ambiente do Owin que é dependência do Identity
                // Feito fora da camada de IoC para não levar o System.Web para fora
                container.RegisterPerWebRequest(() =>
                {
                    if (HttpContext.Current != null && HttpContext.Current.Items["owin.Environment"] == null && container.IsVerifying())
                    {
                        return new OwinContext().Authentication;
                    }
                    return HttpContext.Current.GetOwinContext().Authentication;

                });

                // This is an extension method from the integration package.
                container.RegisterWebApiControllers(config);

                container.Verify();

                GlobalConfiguration.Configuration.DependencyResolver =
                    new SimpleInjectorWebApiDependencyResolver(container);
            }
        }

        protected void Application_Start()
        {
            log4net.Config.XmlConfigurator.Configure();

            var container = new Container();
            container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();

            container.Register<IUserService, UserService>(Lifestyle.Scoped);
            container.Register<IUserRepository, UserHibernateRepository>(Lifestyle.Scoped);
            container.Register<IAssetService, AssetService>(Lifestyle.Scoped);
            container.Register<IAssetViewService, AssetViewService>(Lifestyle.Scoped);
            container.Register<IAssetRepository, AssetHibernateRepository>(Lifestyle.Scoped);
            container.Register<ITokenService, TokenService>(Lifestyle.Scoped);
            container.Register<ITokenRepository, TokenHibernateRepository>(Lifestyle.Scoped);

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);

            // Web API configuration and services

            // Web API routes
            WebApiConfig.Register(GlobalConfiguration.Configuration);
        }

 public static void Initialize(HttpConfiguration config)
 {
     Container container = new Container();
     container.RegisterWebApiRequest<IContactsDbContext>(() => new ContactsDbContext());
     container.RegisterWebApiControllers(config);
     container.Verify();
     config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
 }

 public void ConfigureWebApi()
 {
     container = new Container();
     InitializeContainer(container);
     container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
     container.Verify();
     GlobalConfiguration.Configuration.DependencyResolver =
         new SimpleInjectorWebApiDependencyResolver(container);
 }

        public static void Configure(HttpConfiguration config, Container container)
        {
            container.RegisterWebApiControllers(config, typeof(WebApiConfig).Assembly);

            config.MapHttpAttributeRoutes();
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            config.Formatters.JsonFormatter.UseDataContractJsonSerializer = false;
            config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
            config.EnsureInitialized();
        }

        public static void Build(IAppBuilder app, Container container = null) {
            var loggerFactory = Settings.Current.GetLoggerFactory();
            var logger = loggerFactory.CreateLogger(nameof(AppBuilder));

            if (container == null)
                container = CreateContainer(loggerFactory, logger);

            var config = new HttpConfiguration();
            config.Formatters.Remove(config.Formatters.XmlFormatter);
            config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;

            SetupRouteConstraints(config);
            container.RegisterWebApiControllers(config);

            VerifyContainer(container);

            config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);

            var contractResolver = container.GetInstance<IContractResolver>();
            var exceptionlessContractResolver = contractResolver as ExceptionlessContractResolver;
            exceptionlessContractResolver?.UseDefaultResolverFor(typeof(Connection).Assembly);
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = contractResolver;

            config.Services.Add(typeof(IExceptionLogger), new FoundatioExceptionLogger(loggerFactory.CreateLogger<FoundatioExceptionLogger>()));
            config.Services.Replace(typeof(IExceptionHandler), container.GetInstance<ExceptionlessReferenceIdExceptionHandler>());

            config.MessageHandlers.Add(container.GetInstance<XHttpMethodOverrideDelegatingHandler>());
            config.MessageHandlers.Add(container.GetInstance<EncodingDelegatingHandler>());
            config.MessageHandlers.Add(container.GetInstance<AuthMessageHandler>());

            // Throttle api calls to X every 15 minutes by IP address.
            config.MessageHandlers.Add(container.GetInstance<ThrottlingHandler>());

            // Reject event posts in orgs over their max event limits.
            config.MessageHandlers.Add(container.GetInstance<OverageHandler>());

            EnableCors(config, app);

            container.Bootstrap(config);
            container.Bootstrap(app);

            app.UseWebApi(config);
            SetupSignalR(app, container, loggerFactory);
            SetupSwagger(config);

            if (Settings.Current.WebsiteMode == WebsiteMode.Dev)
                Task.Run(async () => await CreateSampleDataAsync(container));
            
            var context = new OwinContext(app.Properties);
            var token = context.Get<CancellationToken>("host.OnAppDisposing");
            RunMessageBusBroker(container, logger, token);
            RunJobs(container, loggerFactory, logger, token);

            logger.Info("Starting api...");
        }

        public static void Initialize()
        {
            // Create the container as usual.
            var container = new Container();

            //setup logger
            container.RegisterSingle<ILogger>(() =>
                new LoggerConfiguration()
                .WriteTo.ColoredConsole()
                .WriteTo.Trace()
                .CreateLogger()
            );
            
            //instagram config for InstaSharp
            container.RegisterSingle<InstagramConfig>(() =>
            {
                var clientId = ConfigurationManager.AppSettings["clientId"];
                var clientSecret = ConfigurationManager.AppSettings["clientSecret"];
                var callbackUri = ConfigurationManager.AppSettings["callbackUri"];
                var redirectUri = ConfigurationManager.AppSettings["redirectUri"];

                var icfg = new InstagramConfig(clientId, clientSecret);
                icfg.CallbackUri = callbackUri;
                icfg.RedirectUri = redirectUri;
                return icfg;
            }
            );

            // Azure storage account
            container.RegisterSingle(() =>
            {
                var connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
                return CloudStorageAccount.Parse(connectionString);
            });

            // Azure table client
            container.RegisterSingle(() => container.GetInstance<CloudStorageAccount>().CreateCloudTableClient());

            //register our tablesets, in this case we only have one
            container.RegisterWebApiRequest<ITableSet<RealtimeSubscription>>(() =>
                new TableSet<RealtimeSubscription>(container.GetInstance<CloudTableClient>())
                );

            //register repositories
            container.Register<ISubscriptionRepository, SubscriptionRepository>(Lifestyle.Singleton);

            // This is an extension method from the integration package.
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);

            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BootstrapBundleConfig.RegisterBundles();

            var container = new Container();

            container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();

            container.RegisterSingleton<ILinqToLdapLogger>(new SimpleTextLogger());

            container.RegisterSingleton<ILdapConfiguration>(() =>
            {
                var config = new LdapConfiguration()
                    .MaxPageSizeIs(50)
                    .LogTo(container.GetInstance<ILinqToLdapLogger>());

                //Note the optional parameters available on AddMapping.
                //We can perform "late" mapping on certain values, 
                //even for auto and attribute based mapping.
                config.AddMapping(new OrganizationalUnitMap())
                      .AddMapping(new AttributeClassMap<User>());

                // I explicitly mapped User, but I can also let it 
                // get mapped the first time we query for users.
                // This only applies to auto and attribute-based mapping.

                config.ConfigurePooledFactory("directory.utexas.edu")
                      .AuthenticateBy(AuthType.Anonymous)
                      .MinPoolSizeIs(0)
                      .MaxPoolSizeIs(5)
                      .UsePort(389)
                      .ProtocolVersion(3);

                return config;
            });

            //simple context per request only when requested
            container.Register<IDirectoryContext>(() => container.GetInstance<ILdapConfiguration>().CreateContext(), Lifestyle.Scoped);

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
            
            container.Verify();
        }