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;
}
