public static void Configure(IAppBuilder app) { //Autofac configuration var builder = new ContainerBuilder(); // Get your HttpConfiguration. var config = new HttpConfiguration(); // Register your Web API controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterType <AccountController>().InstancePerRequest(); // OPTIONAL: Register the Autofac filter provider. //builder.RegisterWebApiFilterProvider(config); //dependenses resolving builder.RegisterType <MainUserManager>().As <IMainUserManager>().InstancePerRequest(); builder.RegisterType <UserStore <User> >().As <IUserStore <User> >().WithParameter("context", new DBcon()); builder.RegisterType <ApplicationUserManager>().AsSelf(); builder.RegisterType <DBcon>().As <IRepository>().InstancePerRequest(); // Set the dependency resolver to be Autofac. var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacWebApi(config); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public static void Configure(IAppBuilder app) { //Autofac configuration var builder = new ContainerBuilder(); // Get your HttpConfiguration. var config = new HttpConfiguration(); // Register your Web API controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterType<AccountController>().InstancePerRequest(); builder.RegisterType<PhoneBookContext>().InstancePerRequest(); //dependenses resolving builder.RegisterType<MainUserManager>().As<IMainUserManager>().InstancePerRequest(); builder.Register(c => new UserStore<User>(c.Resolve<PhoneBookContext>())).AsImplementedInterfaces().InstancePerRequest(); builder.RegisterType<ApplicationUserManager>().AsSelf(); // Set the dependency resolver to be Autofac. var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacWebApi(config); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public static void Configure(IAppBuilder app) { //Autofac configuration var builder = new ContainerBuilder(); // Get your HttpConfiguration. var config = new HttpConfiguration(); // Register your Web API controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterType <AccountController>().InstancePerRequest(); builder.RegisterType <PhoneBookContext>().InstancePerRequest(); //dependenses resolving builder.RegisterType <MainUserManager>().As <IMainUserManager>().InstancePerRequest(); builder.Register(c => new UserStore <User>(c.Resolve <PhoneBookContext>())).AsImplementedInterfaces().InstancePerRequest(); builder.RegisterType <ApplicationUserManager>().AsSelf(); // Set the dependency resolver to be Autofac. var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacWebApi(config); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public static void ConfigureContainer(IAppBuilder app) { var builder = new ContainerBuilder(); var config = GlobalConfiguration.Configuration; //var config = new HttpConfiguration(); builder.RegisterWebApiFilterProvider(config); builder.RegisterType <NotCatchedExceptionFilterAttribute>().AsWebApiExceptionFilterFor <CustomBaseController>().InstancePerRequest(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterModule(new DataModule()); builder.RegisterModule(new LogicModule()); builder.RegisterModule(new BusinessRulesModule()); builder.RegisterModule(new Log4NetModule()); builder.RegisterModule(new ControllerModule()); Container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(Container); ConfigureOAuthTokenConsumption(app); ConfigureOAuthTokenGeneration(app); WebApiConfig.Register(config); app.UseAutofacMiddleware(Container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public void Configuration(IAppBuilder app) { // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=316888 var builder = new ContainerBuilder(); // STANDARD WEB API SETUP: // Get your HttpConfiguration. In OWIN, you'll create one // rather than using GlobalConfiguration. var config = new HttpConfiguration(); // Register your Web API controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterWebApiFilterProvider(config); builder.RegisterModule(new WebModule(app)); // Register your MVC controllers. builder.RegisterControllers(Assembly.GetExecutingAssembly()); // OPTIONAL: Register model binders that require DI. builder.RegisterModelBinders(Assembly.GetExecutingAssembly()); builder.RegisterModelBinderProvider(); // OPTIONAL: Register web abstractions like HttpContextBase. builder.RegisterModule <AutofacWebTypesModule>(); // OPTIONAL: Enable property injection in view pages. builder.RegisterSource(new ViewRegistrationSource()); // OPTIONAL: Enable property injection into action filters. builder.RegisterFilterProvider(); // register config builder.Register(ct => config).AsSelf().SingleInstance(); //HelpPageConfig.Register(config); // Run other optional steps, like registering filters, // per-controller-type services, etc., then set the dependency resolver // to be Autofac. var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); // OWIN WEB API SETUP: // Register the Autofac middleware FIRST, then the Autofac Web API middleware, // and finally the standard Web API middleware. app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseAutofacMvc(); WebApiConfig.Register(config); ConfigureAuth(app); app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); app.UseWebApi(config); config.EnsureInitialized(); }
public static void Register(ref IAppBuilder app, ref HttpConfiguration config, ref ContainerBuilder builder) { // Register modules builder.RegisterAssemblyModuleFromFile(@".\$ext_safeprojectname$.Modules.Common.Services.dll", (f) => System.Console.WriteLine(" {0}", f)); Console.WriteLine("\r\nLoading WebApis from Directory ..."); builder.RegisterAssemblyModulesFromDirectory(@".\", "$ext_safeprojectname$.Modules.WebApis", "~", (f) => System.Console.WriteLine(" {0}", f)); // Register Web API controller in executing assembly. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Autofac will add middleware to IAppBuilder in the order registered. // The middleware will execute in the order added to IAppBuilder. // !!! This is an example implementation of a small RequestLogger. // !!! A middleware that cares about pre-authentication // builder.RegisterType<RequestLogger>().InstancePerReq/uest(); var container = builder.Build(); // Create and assign a dependency resolver for Web API to use. config.DependencyResolver = (IDependencyResolver) new AutofacWebApiDependencyResolver(container); // This should be the first middleware added to the IAppBuilder. app.UseAutofacMiddleware(container); // Make sure the Autofac lifetime scope is passed to Web API. app.UseAutofacWebApi(config); }
public void Configuration(IAppBuilder appBuilder) { var config = new HttpConfiguration(); appBuilder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); ContainerBuilder containerBuilder = new ContainerBuilder(); containerBuilder.RegisterModule<HostingModule>(); containerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var container = containerBuilder.Build(); var resolver = new AutofacWebApiDependencyResolver(container); config.DependencyResolver = resolver; config.Formatters.Clear(); config.Formatters.Add(new JsonMediaTypeFormatter()); config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }); config.MapHttpAttributeRoutes(); appBuilder.UseAutofacMiddleware(container); appBuilder.UseAutofacWebApi(config); appBuilder.UseWebApi(config); }
public void ConfigureAutofac(IAppBuilder app) { var builder = new ContainerBuilder(); builder.RegisterType <ConfigurationProvider>() .As <IConfigurationProvider>(); builder.RegisterType <TelemetryService>() .As <ITelemetryService>(); builder.RegisterType <DeviceService>() .As <IDeviceService>(); builder.RegisterType <SimulationService>() .As <ISimulationService>(); builder.RegisterType <IotHubRepository>() .As <IIotHubRepository>(); builder.RegisterType <Settings>(); builder.RegisterControllers(Assembly.GetExecutingAssembly()); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var container = builder.Build(); //Setup Autofac dependency resolver for MVC DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); //Setup Autofac dependency resolver for WebAPI HttpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(HttpConfiguration); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); ConfigureFilters(app, config); ConfigureWebApi(app, config); var container = ConfigureDI(app, config); app.UseAutofacWebApi(config); app.UseAutofacMiddleware(container); app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions() { Provider = container.Resolve<IOAuthBearerAuthenticationProvider>() }); app.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions() { AllowInsecureHttp = true, TokenEndpointPath = new PathString("/api/auth/token"), AccessTokenExpireTimeSpan = TimeSpan.FromDays(7), Provider = container.Resolve<IOAuthAuthorizationServerProvider>() }); app.UseWebApi(config); }
public virtual void Configure(IAppBuilder owinApp) { if (owinApp == null) { throw new ArgumentNullException(nameof(owinApp)); } _webApiConfig = new HttpConfiguration(); _webApiConfig.SuppressHostPrincipal(); _webApiConfig.IncludeErrorDetailPolicy = _activeAppEnvironment.DebugMode ? IncludeErrorDetailPolicy.LocalOnly : IncludeErrorDetailPolicy.Never; _webApiConfgurationCustomizers.ToList() .ForEach(webApiConfigurationCustomizer => { webApiConfigurationCustomizer.CustomizeWebApiConfiguration(_webApiConfig); }); _webApiConfig.DependencyResolver = _webApiDependencyResolver; _server = new HttpServer(_webApiConfig); _webApiConfig.MapHttpAttributeRoutes(); _webApiConfig.Routes.MapHttpRoute(name: "default", routeTemplate: "{controller}/{action}", defaults: new { action = RouteParameter.Optional }); owinApp.UseAutofacWebApi(_webApiConfig); _webApiOwinPipelineInjector.UseWebApiOData(owinApp, _server); _webApiConfig.EnsureInitialized(); }
public void Configuration(IAppBuilder app) { TI.trace("StartupServerAutofac", "Begin in memory server setup"); Stopwatch sw = new Stopwatch(); sw.Start(); var configuration = new HttpConfiguration(); //configuration.EnableSystemDiagnosticsTracing(); //configuration.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional } //); //add some temp route hacks configuration.Routes.MapHttpRoute( name: "Login1", routeTemplate: "Login/Login", defaults: new { controller = "Login", action = "LoginGet" }); WebApiConfig.RegisterRoutes(configuration); WebApiConfig.RegisterIntegrationRoutes(configuration); DB_TestingHelper dbHelper = DefaultDbTestingHelper.GetDefaultDbTestingHelper(); ContainerBuilder b = IOCHelper.InitializeServerWithAutofacContainer(dbHelper.Server_DistributrExmxConnection, dbHelper.MongoConnectionString, "win", dbHelper.MongoAuditingConnectionString); Assembly a = Assembly.GetAssembly(typeof(Distributr.WebApi.ApiControllers.CommandController)); b.RegisterApiControllers(a); Autofac.IContainer c = b.Build(); System.Web.Http.Dependencies.IDependencyResolver r = new AutofacWebApiDependencyResolver(c) ; configuration.DependencyResolver = r; app.UseAutofacMiddleware(c); app.UseAutofacWebApi(configuration); app.UseWebApi(configuration); sw.Stop(); TI.trace("[StartupServerAutofac]", string.Format("Time taken to setup in memory server {0}", sw.ElapsedMilliseconds)); }
public void ConfigureDI(IAppBuilder app, HttpConfiguration config) { // Start to build a container that will be able to produce objects var builder = new ContainerBuilder(); // Register all the WebApi controllers in the Api assmebly, so that the container knows about them and can fill their dependencies when a controller is created. builder.RegisterApiControllers(typeof(Startup).Assembly); //Register the objects/types you want to be accessible from the container builder.Register(c => new UserDbContext()).As<UserDbContext>().InstancePerRequest(); builder.Register(c => { return new ApplicationUserManager( new UserStore<ApplicationUser>(c.Resolve<UserDbContext>()) ); }).As<IApplicationUserManager>(); // generate a container var container = builder.Build(); // add a resolver to the WebApi framework so that it knows when it creates a controller it should ask the container for the controller. // before trying to create one with an empty constructor instead config.DependencyResolver = new AutofacWebApiDependencyResolver(container); // Add container into the WebApi pipeline // Note: Not used in this project, but useful for creating custom Middleware and having their dependencies filled in. // See http://alexmg.com/owin-support-for-the-web-api-2-and-mvc-5-integrations-in-autofac/ for more information app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); }
/// <summary> /// Configures the webApi dependency injection to start the service. /// </summary> /// <param name="app">The Azure app service mobile app to configure.</param> public static void ConfigureMobileApp(IAppBuilder app) { HttpConfiguration config = new HttpConfiguration(); config.Services.Add(typeof(IExceptionLogger), new ApplicationInsightsExceptionLogger()); IContainer container = ConfigureWebApiDependencies(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); config.MapHttpAttributeRoutes(); new MobileAppConfiguration() .AddMobileAppHomeController() .MapApiControllers() .ApplyTo(config); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); // Configure Application Insights Telemetry. TelemetryConfiguration.Active.InstrumentationKey = SystemContext.Current.Environment.InstrumentationKey; var rootPath = HttpContext.Current.Server.MapPath("~"); var serverPath = Path.Combine(rootPath, "bin"); using (var scope = container.BeginLifetimeScope()) { var repository = scope.Resolve<IRepository>(); // Do database initialization synchronously repository.InitializeDatabaseIfNotExisting(serverPath).ConfigureAwait(false).GetAwaiter().GetResult(); } }
public void Configuration(IAppBuilder app) { // Setup db context for use in DI app.Use(async (context, next) => { TestDbContext dbContext = _dbContextFactory(context); context.Set(DbContextKey, dbContext); await next(); dbContext.Dispose(); }); var appContainerBuilder = new ContainerBuilder(); appContainerBuilder.Register(ctx => HttpContext.Current.GetOwinContext()).As<IOwinContext>(); appContainerBuilder.Register(c => c.Resolve<IOwinContext>().Get<TestDbContext>(DbContextKey)).As<TestDbContext>(); appContainerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var appContainer = appContainerBuilder.Build(); app.UseAutofacMiddleware(appContainer); var httpConfig = GetWebApiConfiguration(); httpConfig.DependencyResolver = new AutofacWebApiDependencyResolver(appContainer); app.UseWebApi(httpConfig); app.UseAutofacWebApi(httpConfig); }
public void Configuration(IAppBuilder app) { var autoFacBuilder = new ContainerBuilder(); HttpConfiguration config = new HttpConfiguration(); ConfigureAutoFac(autoFacBuilder); autoFacBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly()); autoFacBuilder.RegisterWebApiFilterProvider(config); autoFacBuilder.RegisterWebApiModelBinders(Assembly.GetExecutingAssembly()); var container = autoFacBuilder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); ConfigureAuth(app); WebApiConfig.Register(config); app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); app.UseWebApi(config); config.EnsureInitialized(); }
public void Configuration(IAppBuilder app) { ConfigureAuth(app); var builder = new ContainerBuilder(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterControllers(Assembly.GetExecutingAssembly()); //builder.RegisterType<Class>().As<IClass>(); var container = builder.Build(); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container); var config = new HttpConfiguration { DependencyResolver = new AutofacWebApiDependencyResolver(container) }; app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); app.UseAutofacMvc(); }
public void Configuration(IAppBuilder app) { var builder = new ContainerBuilder(); builder.RegisterAssemblyModules(Assembly.GetExecutingAssembly()); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var container = builder.Build(); var config = new HttpConfiguration { DependencyResolver = new AutofacWebApiDependencyResolver(container) }; //Set here instead of in global.asax WebApiConfig.Register(config); app.UseCors(CorsOptions.AllowAll); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); var scope = config.DependencyResolver.GetRootLifetimeScope(); app.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions { AllowInsecureHttp = true, TokenEndpointPath = new PathString("/token"), AccessTokenExpireTimeSpan = TimeSpan.FromMinutes(30), Provider = scope.Resolve <IOAuthAuthorizationServerProvider>(), RefreshTokenProvider = scope.Resolve <IAuthenticationTokenProvider>() }); app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions()); }
public static void Register(IAppBuilder app, HttpConfiguration config) { var aspNetIdentityAssembly = typeof(IMarkerAspNetIdentityInterface).Assembly; var cornhouseCoreAssembly = typeof (IMarkerCornhouseCoreInterface).Assembly; var executingAssembly = Assembly.GetExecutingAssembly(); var builder = new ContainerBuilder(); builder.Register(c => InitializeRavenDb.Initialize(aspNetIdentityAssembly)).As<IDocumentStore>().InstancePerLifetimeScope(); builder.Register(c => c.Resolve<IDocumentStore>().OpenAsyncSession()).As<IAsyncDocumentSession>().InstancePerRequest(); builder.Register(c => HttpContext.Current.User).InstancePerRequest(); builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerRequest(); builder.RegisterType<ApplicationRoleManager>().AsSelf().InstancePerRequest(); builder.RegisterType<RavenUserStore>().AsSelf().InstancePerRequest(); builder.RegisterType<RavenRoleStore>().AsSelf().InstancePerRequest(); builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest(); builder.Register(c => app.GetDataProtectionProvider()).InstancePerRequest(); builder.RegisterApiControllers(executingAssembly); builder.RegisterApiControllers(aspNetIdentityAssembly); builder.RegisterAssemblyTypes(executingAssembly).AsImplementedInterfaces().InstancePerRequest(); builder.RegisterAssemblyTypes(aspNetIdentityAssembly).AsImplementedInterfaces().InstancePerRequest(); builder.RegisterAssemblyTypes(cornhouseCoreAssembly).AsImplementedInterfaces().InstancePerRequest(); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); }
private void ConfigureContainer(IAppBuilder app) { var assembly = this.GetType().Assembly; var builder = new ContainerBuilder(); builder.RegisterApiControllers(assembly) .InstancePerLifetimeScope(); var modules = AssemblyHelper.Scan <Module>(assembly); modules.ForEach(m => builder.RegisterModule(m)); builder.RegisterAssemblyModules(assembly); extensionModules.Register(new RegisterContext(builder)); var container = builder.Build(); var dependencyResolver = new AutofacWebApiDependencyResolver(container); Config.DependencyResolver = dependencyResolver; // add lifetimescope to owin context. app.UseAutofacMiddleware(container); // add lifetimescope from owin to web api scope app.UseAutofacWebApi(Config); IoC.Initialize(container); app.UseWebApi(Config); logger.Info("Configure container completed....."); }
/// <summary> /// Registers the configuration /// </summary> public static IContainer Register(IAppBuilder app, HttpConfiguration configuration, IServiceFacade serviceFacade = null) { Condition.Requires(configuration, "configuration").IsNotNull(); var builder = new ContainerBuilder(); builder.RegisterModule(new ServiceModule(serviceFacade)); // controllers builder.RegisterApiControllers(typeof (ControllerBase).Assembly); // request builder.RegisterHttpRequestMessage(configuration); // authorization builder.RegisterType<AuthorizationServerProvider>().As<IOAuthAuthorizationServerProvider>().SingleInstance(); // set resolver var container = builder.Build(); // set the dependency resolver for Web API var resolver = new AutofacWebApiDependencyResolver(container); configuration.DependencyResolver = resolver; app.UseAutofacMiddleware(container); app.UseAutofacWebApi(configuration); ConfigureOAuth(app, container); app.UseWebApi(configuration); return container; }
public void Configuration(IAppBuilder app) { var builder = new ContainerBuilder(); // STANDARD WEB API SETUP: // Get your HttpConfiguration. In OWIN, you'll create one // rather than using GlobalConfiguration. var config = new HttpConfiguration(); // Register your Web API controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Run other optional steps, like registering filters, // per-controller-type services, etc., then set the dependency resolver // to be Autofac. //builder.RegisterType<StarWarsSchema>().As<ISchema>(); builder.RegisterType<PlanningGameSchema>().As<ISchema>(); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); // OWIN WEB API SETUP: // Register the Autofac middleware FIRST, then the Autofac Web API middleware, // and finally the standard Web API middleware. app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public void Configuration(IAppBuilder app) { // Loading a new configuration. var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); // Loading formatters. var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First(); jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); jsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html")); // Resolving Dependencies var builder = new ContainerBuilder(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterModule(new DataLayerModule()); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); // Configuring Mappings DataLayerMapping.AutoMapperStart(); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public static HttpConfiguration ConfigureContainer(IAppBuilder app) { var configuration = GlobalConfiguration.Configuration; var builder = new ContainerBuilder(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).InstancePerRequest(); builder.RegisterWebApiFilterProvider(configuration); builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()) .Where(x => x.Namespace.EndsWith(".Implementations")) .AsImplementedInterfaces(); builder.RegisterGeneric(typeof(GenericRepository <>)).As(typeof(IGenericRepository <>)).InstancePerDependency(); builder.RegisterType <AgileDbContext>().As <IAgileDbContext>().InstancePerRequest(); LoadAndRegisterAssemblies(builder); var container = builder.Build(); var resolver = new AutofacWebApiDependencyResolver(container); configuration.DependencyResolver = resolver; app.UseAutofacMiddleware(container); app.UseAutofacWebApi(configuration); return(configuration); }
private void ConfigureDependencies(IAppBuilder app, HttpConfiguration config) { // configure container ContainerBuilder builder = new ContainerBuilder(); // bind all webapi controllers builder.RegisterApiControllers(Assembly.GetExecutingAssembly()) .InstancePerRequest(); // register context builder.RegisterType<TemplateAppContext>() .AsSelf() .InstancePerRequest(); // register services builder.RegisterType<ConfigurationService>() .As<IConfigurationService>() .InstancePerLifetimeScope(); builder.RegisterType<UserService>() .As<IUserService>() .InstancePerRequest(); // create container IContainer container = builder.Build(); // bind app to autofac app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); }
public void ConfigureAutofac(IAppBuilder app) { var builder = new ContainerBuilder(); // register the class that sets up bindings between interfaces and implementation builder.RegisterModule(new WebAutofacModule()); // register configuration provider builder.RegisterType<ConfigurationProvider>().As<IConfigurationProvider>(); // register Autofac w/ the MVC application builder.RegisterControllers(typeof(MvcApplication).Assembly); // Register the WebAPI controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var container = builder.Build(); // Setup Autofac dependency resolver for MVC DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); // Setup Autofac dependency resolver for WebAPI Startup.HttpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(container); // 1. Register the Autofac middleware // 2. Register Autofac Web API middleware, // 3. Register the standard Web API middleware (this call is made in the Startup.WebApi.cs) app.UseAutofacMiddleware(container); app.UseAutofacWebApi(Startup.HttpConfiguration); }
protected virtual void Start(IAppBuilder app, IContainer container) { var config = CreateHttpConfiguration(); ConfigureWebApi(config); if (Settings.ShowExceptionDetails) { app.UseErrorPage(new ErrorPageOptions { ShowExceptionDetails = true, ShowSourceCode = true }); } app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); RegisterSignalR(container, app); app.UseStageMarker(PipelineStage.MapHandler); RegisterServices(container, app, config); RegisterShutdown(app, container); StartIndexingIfConfigured(container); }
public void Configuration(IAppBuilder app) { var builder = new ContainerBuilder(); var config = new HttpConfiguration(); // Identity Dependencies builder.RegisterType<ApplicationDbContext>().AsSelf().InstancePerLifetimeScope(); builder.RegisterType<ApplicationUserStore>().As<IUserStore<ApplicationUser>>().InstancePerLifetimeScope(); builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerLifetimeScope(); builder.RegisterType<ApplicationSignInManager>().AsSelf().InstancePerLifetimeScope(); builder.Register<IAuthenticationManager>(c => HttpContext.Current.GetOwinContext().Authentication); // Web Application Dependencies builder.RegisterType<StoreContext>().AsSelf().InstancePerRequest(); builder.RegisterType<StoreItemService>().AsSelf(); builder.RegisterType<ReceivingItemService>().AsSelf(); // Autofac MVC Boilerplate builder.RegisterModule<AutofacWebTypesModule>(); builder.RegisterFilterProvider(); builder.RegisterControllers(typeof(MvcApplication).Assembly); //Autofac WebAPI2 Boilerplate builder.RegisterApiControllers(typeof(MvcApplication).Assembly); builder.RegisterWebApiFilterProvider(config); var container = builder.Build(); GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); app.UseAutofacMiddleware(container); app.UseAutofacMvc(); app.UseAutofacWebApi(config); ConfigureAuth(app); }
public void Configuration(IAppBuilder app) { app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); var builder = new ContainerBuilder(); var config = new HttpConfiguration(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterType <CityGamesContext>().AsSelf().As <DbContext>().InstancePerLifetimeScope(); builder.RegisterType <UnitOfWork>().AsImplementedInterfaces(); builder.RegisterType <UnitOfWork>().As <UnitOfWork>(); builder.RegisterWebApiFilterProvider(config); RegisterAutoMapperConfiguration(builder); RegisterServices(builder); RegisterIdentity(app, builder); builder.RegisterWebApiFilterProvider(config); WebApiConfig.Register(config); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); ConfigureOAuth(app); app.UseWebApi(config); }
public static void Configure(IAppBuilder app) { if (app == null) throw new ArgumentNullException("app"); IContainer container = IocConfiguration.BuildContainer(actorSystemName: "Wakka"); app.UseAutofacMiddleware(container); HttpConfiguration webApiConfiguration = new HttpConfiguration { // Only used when mapping attribute routes. DependencyResolver = new AutofacWebApiDependencyResolver(container) }; app.UseAutofacWebApi(webApiConfiguration); // Share OWIN lifetime scope. webApiConfiguration.MapHttpAttributeRoutes(); webApiConfiguration.EnsureInitialized(); app.UseWebApi(webApiConfiguration); // Explicitly start the actor system when the OWIN app is started. ActorSystem actorSystem = container.ResolveNamed<ActorSystem>("Wakka"); // Try to gracefully shut down the actor system when the host is shutting down. AppProperties appProperties = new AppProperties(app.Properties); appProperties.OnAppDisposing.Register(() => { actorSystem.Shutdown(); actorSystem.AwaitTermination( timeout: TimeSpan.FromSeconds(5) ); }); }
public void Configuration(IAppBuilder app) { HttpConfiguration config = new HttpConfiguration(); // autofac configuration zone app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); var builder = new ContainerBuilder(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterWebApiFilterProvider(config); builder.RegisterGeneric(typeof(Repository <>)).As(typeof(IRepository <>)).InstancePerDependency(); builder.RegisterType <IdentityDatabaseContext>().As(typeof(DbContext)).SingleInstance(); builder.RegisterType <CustomUserStore>().As(typeof(IUserStore <User, long>)).SingleInstance(); builder.RegisterType <IdentityUserManager>().SingleInstance(); builder.RegisterType <IdentityFactoryOptions <IdentityUserManager> >().SingleInstance(); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); // end of autofac configure WebApiConfig.Register(config); ConfigureAuth(app, container.Resolve <IdentityUserManager>()); app.UseWebApi(config); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); var container = ConfigureAutoFac.ConfigureMvc(); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); //Dit op Configure laten staan, dit wordt namelijk niet in web requests gebruikt // Remove the old formatter, add the new one. var formatter = new JsonMediaTypeFormatter(); formatter.SerializerSettings = new JsonSerializerSettings { Formatting = Formatting.Indented, ContractResolver = new CamelCasePropertyNamesContractResolver(), ReferenceLoopHandling = ReferenceLoopHandling.Ignore }; config.Formatters.Remove(config.Formatters.JsonFormatter); config.Formatters.Add(formatter); config.Formatters.Remove(config.Formatters.XmlFormatter); WebApiConfig.Register(config); app.UseCors(CorsOptions.AllowAll); app.UseAutofacMiddleware(container); app.UseAutofacMvc(); app.UseAutofacWebApi(config); app.UseWebApi(config); ConfigureAuth(app); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); WebApiConfig.Register(config); var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First(); jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); //增加过滤 config.Filters.Add(new ValidateModelAttribute()); config.Filters.Add(new APIExceptionFilterAttribute()); //solved from http://stackoverflow.com/questions/12905174/how-to-add-custom-modelvalidatorproviders-to-web-api-project //自定义配置 config.Services.Add(typeof(ModelValidatorProvider), new FluentValidationModelValidatorProvider(new QZCHYValidatorFactory())); // app.UseCors() ConfigureOAuth(app); //initialize engine context EngineContext.Initialize(false, config); // Register the Autofac middleware FIRST, then the Autofac Web API middleware, // and finally the standard Web API middleware. app.UseAutofacMiddleware(EngineContext.Current.ContainerManager.Container); app.UseAutofacWebApi(config); app.UseWebApi(config); SqlServerTypes.Utilities.LoadNativeAssemblies(System.Web.HttpContext.Current.Server.MapPath("~/bin")); }
public void Configuration(IAppBuilder app) { app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); var builder = new ContainerBuilder(); var config = new HttpConfiguration(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterType<InstantDeliveryContext>() .AsSelf() .As<DbContext>() // for UserStore .InstancePerLifetimeScope(); builder.Register(c => new RegularPricingStrategy()) .AsImplementedInterfaces() .SingleInstance(); RegisterIdentity(app, builder); builder.RegisterWebApiFilterProvider(config); WebApiConfig.Register(config); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); // has to be called before UseWebApi ConfigureOAuth(app); app.UseWebApi(config); }
/// <summary> /// /// </summary> /// <param name="app"></param> public void Configuration(IAppBuilder app) { // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=316888 ConfigureAuth(app); EngineContext.Initialize(false); HttpConfiguration config = GlobalConfiguration.Configuration; config.DependencyResolver = new AutofacWebApiDependencyResolver(EngineContext.Current.ContainerManager.Container); WebApiConfig.Register(config); app.UseAutofacWebApi(config); app.UseWebApi(config); config.EnsureInitialized(); //log application start try { //log var logger = EngineContext.Current.Resolve <ILogger>(); logger.Information("Application started", null, null); } catch (Exception) { //don't throw new exception if occurs } }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); config.Routes.MapHttpRoute( "DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }); var builder = new ContainerBuilder(); // Register Web API controller in executing assembly. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Register a logger service to be used by the controller and middleware. builder.Register(c => new Logger()).As <ILogger>().InstancePerRequest(); // Autofac will add middleware to IAppBuilder in the order registered. // The middleware will execute in the order added to IAppBuilder. builder.RegisterType <FirstMiddleware>().InstancePerRequest(); builder.RegisterType <SecondMiddleware>().InstancePerRequest(); var container = builder.Build(); // Create an assign a dependency resolver for Web API to use. config.DependencyResolver = new AutofacWebApiDependencyResolver(container); // This should be the first middleware added to the IAppBuilder. app.UseAutofacMiddleware(container); // Make sure the Autofac lifetime scope is passed to Web API. app.UseAutofacWebApi(config); app.UseWebApi(config); }
/// <summary> /// /// </summary> /// <param name="app"></param> public void Configuration(IAppBuilder app) { ConfigureOAuth(app); HttpConfiguration config = new HttpConfiguration(); //配置api信息 app.UseWebApi(config); app.UseAutofacWebApi(config); log4net.Config.XmlConfigurator.Configure(); app.UseAutofacMiddleware(ContainerManager.Container); //WebApiConfig.Register(config); //使用跨域 app.UseCors(CorsOptions.AllowAll); #region 接受主数据 MDS.Api.PushOptions pushOptions = new MDS.Api.PushOptions { ClientId = _clientId, ClientKey = _clientSecret }; pushOptions.UsePushListener <OrganizationPushListener>(MDS.Api.DataCategory.Organization); pushOptions.UsePushListener <UserPushListener>(MDS.Api.DataCategory.User); pushOptions.UsePushListener <PositionPushListener>(MDS.Api.DataCategory.Position); pushOptions.OnException += PushOptions_OnException; app.UseMasterDataPushServer(pushOptions); #endregion //开始后台工作 Jobs.JobScheduler.Start(); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); config.Routes.MapHttpRoute( "DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional}); var builder = new ContainerBuilder(); // Register Web API controller in executing assembly. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Register a logger service to be used by the controller and middleware. builder.Register(c => new Logger()).As<ILogger>().InstancePerRequest(); // Autofac will add middleware to IAppBuilder in the order registered. // The middleware will execute in the order added to IAppBuilder. builder.RegisterType<FirstMiddleware>().InstancePerRequest(); builder.RegisterType<SecondMiddleware>().InstancePerRequest(); var container = builder.Build(); // Create and assign a dependency resolver for Web API to use. config.DependencyResolver = new AutofacWebApiDependencyResolver(container); // This should be the first middleware added to the IAppBuilder. app.UseAutofacMiddleware(container); // Make sure the Autofac lifetime scope is passed to Web API. app.UseAutofacWebApi(config); app.UseWebApi(config); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); ConfigureFilters(app, config); ConfigureWebApi(app, config); var container = ConfigureDI(app, config); app.UseAutofacWebApi(config); app.UseAutofacMiddleware(container); app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions() { Provider = container.Resolve <IOAuthBearerAuthenticationProvider>() }); app.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions() { AllowInsecureHttp = true, TokenEndpointPath = new PathString("/api/auth/token"), AccessTokenExpireTimeSpan = TimeSpan.FromDays(7), Provider = container.Resolve <IOAuthAuthorizationServerProvider>() }); app.UseWebApi(config); }
// This code configures Web API. The Startup class is specified as a type // parameter in the WebApp.Start method. public void Configuration(IAppBuilder appBuilder) { // Configure Web API for self-host. var config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.MapHttpAttributeRoutes(); var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First(); jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.Formatters.Remove(config.Formatters.XmlFormatter); var builder = new ContainerBuilder(); IocConfig.RegisterDependencies(builder); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); appBuilder.UseAutofacMiddleware(container); appBuilder.UseAutofacWebApi(config); appBuilder.UseWebApi(config); }
public static void Config(IAppBuilder app, HttpConfiguration config) { var builder = new ContainerBuilder(); //register controllers builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).InstancePerRequest(); builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()) //Register ***Services .Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces(); //Register Auth classes builder.RegisterType<AppDbContext>().As<DbContext>().InstancePerRequest(); builder.RegisterType<UserStore<ApplicationUser>>().AsImplementedInterfaces().InstancePerRequest(); builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerRequest(); builder.RegisterType<RoleStore<IdentityRole>>().AsImplementedInterfaces().InstancePerRequest(); builder.RegisterType<ApplicationRoleManager>().AsSelf().InstancePerRequest(); //Register generics builder.RegisterGeneric(typeof(Repository<>)).AsImplementedInterfaces(); // Register dependecy of MailerApiController from Postal dll builder.RegisterType<EmailService>().As<IEmailService>(); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); //WebAPI app.UseAutofacMiddleware(container); //Register before MVC / WebApi app.UseAutofacWebApi(config); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }); // Remove XML formatter var json = config.Formatters.JsonFormatter; json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None; config.Formatters.Remove(config.Formatters.XmlFormatter); // NetIn and assign a dependency resolver for Web API to use. var dependencyResolver = new DependencyResolver(); config.DependencyResolver = dependencyResolver; // Filter for loggering var logActionFilter = new Containerizer.Filters.LogActionFilter(DependencyResolver.logger); config.Filters.Add(logActionFilter); var exceptionLoggingFilter = new Containerizer.Filters.ExceptionLoggingFilter(DependencyResolver.logger); config.Filters.Add(exceptionLoggingFilter); // Make sure the Autofac lifetime scope is passed to Web API. app.UseAutofacWebApi(config); app.MapWebSocketPattern<ContainerProcessHandler>("/api/containers/(?<handle>.*)/run", dependencyResolver); app.UseWebApi(config); }
public void Configuration(IAppBuilder appBuilder) { var config = new HttpConfiguration(); var container = ContainerConfig.Build(); WebApiConfig.Register(config, container); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); appBuilder.UseAutofacMiddleware(container); appBuilder.UseAutofacWebApi(config); appBuilder.UseWebApi(config); var fileSystem = new EmbeddedResourceFileSystem(typeof(Global).Assembly, "Editor.Front"); var options = new FileServerOptions { FileSystem = fileSystem }; options.StaticFileOptions.FileSystem = fileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; appBuilder.UseFileServer(options); appBuilder.MapWebSocketPattern <EditorWebSocket>("/ws/editor/(?<documentId>[0-9A-Fa-f\\-]{36})/(?<clientId>[0-9A-Fa-f\\-]{36})", new AutofacServiceLocator(container)); }
/// <summary> /// Registers the configuration /// </summary> public static IContainer Register(IAppBuilder app, HttpConfiguration configuration, IServiceFacade serviceFacade = null) { Condition.Requires(configuration, "configuration").IsNotNull(); var builder = new ContainerBuilder(); builder.RegisterModule(new ServiceModule(serviceFacade)); // controllers builder.RegisterApiControllers(typeof(ControllerBase).Assembly); // request builder.RegisterHttpRequestMessage(configuration); // authorization builder.RegisterType <AuthorizationServerProvider>().As <IOAuthAuthorizationServerProvider>().SingleInstance(); // set resolver var container = builder.Build(); // set the dependency resolver for Web API var resolver = new AutofacWebApiDependencyResolver(container); configuration.DependencyResolver = resolver; app.UseAutofacMiddleware(container); app.UseAutofacWebApi(configuration); ConfigureOAuth(app, container); app.UseWebApi(configuration); return(container); }
protected virtual void Start(IAppBuilder app, IContainer container) { var config = CreateHttpConfiguration(); ConfigureWebApi(config, container); if (Settings.ShowExceptionDetails) { app.UseErrorPage(new ErrorPageOptions { ShowExceptionDetails = true, ShowSourceCode = true }); } app.UseAutofacMiddleware(container); app.UseStageMarker(PipelineStage.Authenticate); app.UseAutofacWebApi(config); app.UseWebApi(config); RegisterSignalR(container, app); app.UseStageMarker(PipelineStage.MapHandler); RegisterServices(container, app, config); RegisterShutdown(app, container); StartIndexingIfConfigured(container); }
public void Configuration(IAppBuilder app) { // Use DotNetEnv v1.1.0 due to it is the only version with out dependencies var envFilePath = System.IO.Path.Combine(System.Web.HttpRuntime.AppDomainAppPath, ".env"); if (File.Exists(envFilePath)) { DotNetEnv.Env.Load(envFilePath); } var corsOptions = CorsConfig.ConfigureCors(Settings.AllowedOrigins); app.UseCors(corsOptions); // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=316888 HttpConfiguration config = new HttpConfiguration(); config.Filters.Add(new ExceptionFilter()); AutofacConfig.Configure(config); FormatterConfig.Configure(config); RouteConfig.Configure(config); LoggerConfig.Configure(config); OptionsMessageHandlerConfig.Configure(config); SwaggerConfig.Configure(config); app.UseAutofacMiddleware(AutofacConfig.Container); app.UseAutofacWebApi(config); app.PreventResponseCaching(); app.UseAuthentication(); app.UseWebApi(config); }
public void Configuration(IAppBuilder app) { AutoMapperConfig.Initialize(); AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); var container = AutofacConfig.ConfigureContainer(); var config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
private void OwinStartup(IAppBuilder app) { HttpConfiguration config = new HttpConfiguration(); IDependencyResolver resolver; #if true Unity.IUnityContainer uc = new Unity.UnityContainer(); uc.RegisterInstance(typeof(IPlop), new Plop()); resolver = new UnityResolver(uc); #else Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder(); builder.RegisterApiControllers(typeof(WorkerRole).Assembly); builder.RegisterInstance(new Plop()).As <IPlop>(); Autofac.IContainer container = builder.Build(); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); resolver = new AutofacWebApiDependencyResolver(container); #endif config.DependencyResolver = resolver; config.MapHttpAttributeRoutes(); config.EnsureInitialized(); app.UseWebApi(config); }
/// <summary> /// Configuration method to configure startup of application /// </summary> /// <param name="app"></param> public void Configuration(IAppBuilder app) { HttpConfiguration configuration = new HttpConfiguration(); WebApiConfig.Register(configuration); //////////////////////////////AUTOFAC CONFIG/////////////////////START var builder = new ContainerBuilder(); // Register your Web API controllers. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); new ServicesRegistry().Register(builder); var container = builder.Build(); // Create the depenedency resolver. var resolver = new AutofacWebApiDependencyResolver(container); configuration.DependencyResolver = resolver; app.UseAutofacMiddleware(container); app.UseAutofacWebApi(configuration); app.UseWebApi(configuration); }
public void ConfigureAutofac(IAppBuilder app) { var builder = new ContainerBuilder(); builder.RegisterType<ConfigurationProvider>() .As<IConfigurationProvider>(); builder.RegisterType<TelemetryService>() .As<ITelemetryService>(); builder.RegisterType<IotHubRepository>() .As<IIotHubRepository>(); builder.RegisterControllers(Assembly.GetExecutingAssembly()); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var container = builder.Build(); //Setup Autofac dependency resolver for MVC DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); //Setup Autofac dependency resolver for WebAPI HttpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(HttpConfiguration); }
public void Configuration(IAppBuilder app) { AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); log4net.Config.XmlConfigurator.Configure(); var builder = new ContainerBuilder(); var config = GlobalConfiguration.Configuration; builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterWebApiFilterProvider(config); builder.RegisterWebApiModelBinderProvider(); builder.RegisterModule(new AutofacConfig("DefaultConnection")); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); app.UseWebApi(config); }
public void Configuration(IAppBuilder app) { var builder = new ContainerBuilder(); // get HttpConfiguration var config = GlobalConfiguration.Configuration; // register Web API controllers builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // OPTIONAL: Register the Autofac filter provider. builder.RegisterWebApiFilterProvider(config); Bootstrapper.RegisterAutofac(builder); // set the dependency resolver to be Autofac var container = builder.Build(); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); ConfigureOAuth(app); app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); app.UseWebApi(config); }
// This code configures Web API. The Startup class is specified as a type // parameter in the WebApp.Start method. public void Configuration(IAppBuilder appBuilder) { // Configure Web API for self-host. HttpConfiguration config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.DependencyResolver = new AutofacWebApiDependencyResolver(Workspace.Container); config.Formatters.Add(new BrowserJsonFormatter()); var hubConfig = new HubConfiguration { EnableDetailedErrors = true }; hubConfig.Resolver = Workspace.Container.Resolve <IDependencyResolver>(); appBuilder.UseAutofacMiddleware(Workspace.Container); appBuilder.UseAutofacWebApi(config); appBuilder.UseCompressionModule(); appBuilder.UseCors(CorsOptions.AllowAll); appBuilder.UseWebApi(config); appBuilder.MapSignalR(hubConfig); //appBuilder.UseFileServer(new FileServerOptions //{ // FileSystem = new PhysicalFileSystem(@"WebApi\Static\"), // RequestPath = new PathString("/app"), //}); }
public static void ConfigureContainer(IAppBuilder app) { var container = CreateContainer(); //Autofac MVC registration DependencyResolver.SetResolver(new Autofac.Integration.Mvc.AutofacDependencyResolver(container)); app.UseAutofacMiddleware(container); app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); app.UseAutofacMvc(); //Autofac WebApi2 registration HttpConfiguration config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First(); jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); app.UseAutofacWebApi(config); app.UseWebApi(config); // Set the dependency resolver to be Autofac. for Signalr GlobalHost.DependencyResolver = new Autofac.Integration.SignalR.AutofacDependencyResolver(container); }
private static void ConfigureWebApiViaOwin(IAppBuilder appBuilder) { var config = ConfigureApi(); appBuilder.UseAutofacMiddleware(EngineContext.Current.ContainerManager.Container); appBuilder.UseAutofacWebApi(config); appBuilder.UseWebApi(config); }
private void SetupAutofacWebApi(IAppBuilder appBuilder, HttpConfiguration config) { //Do not chage autofac registration order var container = EngineContext.Current.ContainerManager.Container; appBuilder.UseAutofacMiddleware(container); appBuilder.UseAutofacWebApi(config); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); }
public void Configuration(IAppBuilder application) { _httpConfiguration.MapHttpAttributeRoutes(); _httpConfiguration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; application.UseAutofacMiddleware(_rootLifetimeScope); application.UseAutofacWebApi(_httpConfiguration); application.UseWebApi(_httpConfiguration); }
public void Configuration(IAppBuilder app) { var container = IocConfig.BuildContainer(); var httpConf = ConfigureWebApi(new AutofacWebApiDependencyResolver(container)); ConfigureAuth(app); app.UseAutofacWebApi(httpConf); app.UseWebApi(httpConf); }
public void Configuration(IAppBuilder app) { var httpConfiguration = GetHttpConfiguration(app); ConfigureOAuth(app, httpConfiguration); WebApiConfig.Register(httpConfiguration); app.UseAutofacWebApi(httpConfiguration); app.UseWebApi(httpConfiguration); }
public static void Bootstrap(IAppBuilder app) { var mvcContainer = ConfigureMvcContainer(); app.UseAutofacMiddleware(mvcContainer); app.UseAutofacWebApi(GlobalConfiguration.Configuration); app.UseAutofacMvc(); }
public static IContainer Register(IAppBuilder app, HttpConfiguration config) { ContainerBuilder containerBuilder = new ContainerBuilder(); ConfigureRepositories(containerBuilder); ConfigureDependencies(containerBuilder); var container = containerBuilder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); return container; }