public void Verify_Routing_Rules()
{
// Initialize AutoFac WebApi stuff
IoC.BuildContainer();
var config = new HttpConfiguration();
var webApiDependencyResolver = new AutofacWebApiDependencyResolver(IoC.Container);
config.DependencyResolver = webApiDependencyResolver;
WebApiConfig.RegisterRoutes(config.Routes);
// arrange/act/assert
var route = RouteInfo.Verify(config, HttpMethod.Get, BaseUri + "1", typeof(ProductsController), "Default");
route.VerifyRouteData("id", "1");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Get, BaseUri, typeof(ProductsController), "Default");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Get, BaseUri + "details", typeof(ProductsController), "Details");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Get, BaseUri + "?$filter=startswith(Name, 'Mountain') eq true&$top=2&$skip=3", typeof(ProductsController), "Default");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Post, BaseUri, typeof(ProductsController), "Default");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Put, BaseUri + "1", typeof(ProductsController), "Default");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Put, BaseUri + "1/mark-sold-out", typeof(ProductsController), "MarkSoldOut");
// arrange/act/assert
route = RouteInfo.Verify(config, HttpMethod.Delete, BaseUri + "1", typeof(ProductsController), "Default");
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Initialize the database.
Database.SetInitializer(new SalesDbInitializer());
using (var context = new SalesContext())
{
context.Database.Initialize(force: true);
}
// Configuring Autofac
var config = GlobalConfiguration.Configuration;
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Registering all API controllers.
builder.RegisterType<SalesContext>().As<SalesContext>(); // Don't forget to register our DbContext class!
// 註冊你的 commands 和 quieries
builder.RegisterType<CustomerCommand>().As<ICustomerCommands>();
builder.RegisterType<CustomerQueries>().As<ICustomerQueries>();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
}
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));
}
/// <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 static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new {id = RouteParameter.Optional}
);
config.EnableQuerySupport();
config.EnableSystemDiagnosticsTracing();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver();
var builder = new ContainerBuilder();
builder.RegisterType<ToDoItemMap>().As<IMap<ToDoItem, ToDoItemDto>>();
var webApiAssembly = Assembly.Load("WebApi");
builder.RegisterApiControllers(webApiAssembly);
var dataAssembly = Assembly.Load("Data");
builder.RegisterAssemblyTypes(dataAssembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces()
.InstancePerApiRequest();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
}
protected void Application_Start()
{
EngineContext.Initialize(false);
var configuration = GlobalConfiguration.Configuration;
var resolver = new AutofacWebApiDependencyResolver(
EngineContext.Current.ContainerManager.Container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
//注册AutoMapper
//TODO：这里可能产生耦合，考虑是否使用接口
var mapperConfig = new AutoMapperRegistrar();
mapperConfig.Register();
//GlobalConfiguration.Configuration.DependencyResolver
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//TODO 阻止循环引用序列化（记录到RRDL）
//阻止循环引用序列化
var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
//json.SerializerSettings.PreserveReferencesHandling =
// Newtonsoft.Json.PreserveReferencesHandling.Objects;
json.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
}
protected void Application_Start()
{
Error += (sender, args) => Debug.Write(args);
(new FeatureBeeContext()).Initialize(true);
var container = new DIConfiguration().BuildApplicationContainer();
// Configure MVC with the dependency resolver.
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Configure SignalR with the dependency resolver.
GlobalHost.DependencyResolver = new Autofac.Integration.SignalR.AutofacDependencyResolver(container);
// Configure Web API with the dependency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
protected void Application_Start()
{
//GlobalHost.DependencyResolver.UseRedis("127.0.0.1", 6379, string.Empty, "AgileR");
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var builder = new ContainerBuilder();
builder.RegisterModule<AutofacWebTypesModule>();
builder.RegisterAssemblyModules(Assembly.GetExecutingAssembly());
var container = builder.Build();
var autofacDependencyResolver = new AutofacDependencyResolver(container);
DependencyResolver.SetResolver(autofacDependencyResolver);
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
GlobalConfiguration.Configuration.IncludeErrorDetailPolicy =
IncludeErrorDetailPolicy.Always;
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
//GlobalConfiguration.Configuration.EnableQuerySupport();
// To disable tracing in your application, please comment out or remove the following line of code
// For more information, refer to: http://www.asp.net/web-api
GlobalConfiguration.Configuration.EnableSystemDiagnosticsTracing();
}
public static IContainer RegisterContainer(HttpConfiguration config) {
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
//Settings
builder.RegisterType<WebConfigApplicationSettings>().As<IApplicationSettings>().InstancePerRequest();
//Logger
builder.RegisterType<Log4NetAdapter>().As<ILogger>().InstancePerRequest();
//EF
builder.RegisterType<ApplicationDbContext>().As<IApplicationDbContext>().InstancePerRequest();
builder.RegisterType<IdentityDbContext<ApplicationUser>>();
//Usermanager
//builder.RegisterInstance(new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())));
//Services
builder.RegisterType<CurrentUserService>().As<ICurrentUserService>().InstancePerRequest();
builder.RegisterType<AccountService>().As<IAccountService>().InstancePerRequest();
builder.RegisterType<TripService>().As<ITripService>().InstancePerRequest();
builder.RegisterType<AddressService>().As<IAddressService>().InstancePerRequest();
builder.RegisterType<CarService>().As<ICarService>().InstancePerRequest();
builder.RegisterType<GoogleDistanceCalculatorService>().As<IDistanceCalculatorService>().InstancePerRequest();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
return container;
}
public static void RegisterIoc()
{
var builder = new ContainerBuilder();
// registrar autofac para resolver las dependencías de los controladores
builder.RegisterControllers(typeof(Tarea.Web.Controllers.TareaController).Assembly);
// registrar para IDatabase - 1 Instancia por request
builder.Register(c => new Database("Default"))
.As<IDatabase>()
.SingleInstance();
// registar el servicio
builder.RegisterType<TareaServicio2>().
As<ITareaServicio>().
InstancePerRequest();
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)).InstancePerRequest();
builder.RegisterType<Uow>().As<IUnitOfWork>().InstancePerRequest();
// registar para los filters (aun no tenemos)
builder.RegisterFilterProvider();
builder.RegisterApiControllers(typeof(Tarea.Web.Controllers.TareaDataController).Assembly);
// completar la config de autofac
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
private static void InitializeIoC(HttpConfiguration config)
{
var builder = new ContainerBuilder();
//builder.ConfigureWebApi(GlobalConfiguration.Configuration);
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterType<EventoRepository>().As<Eventos>();
builder.RegisterType<GrupoRepository>().As<Grupos>();
builder.RegisterType<LocalRepository>().As<Locais>();
builder.RegisterType<UsuarioRepository>().As<Usuarios>();
builder.RegisterType<UsuarioTokenRepository>().As<UsuarioTokens>();
builder.RegisterType<RemoveConflitoService>().As<DomainEventHandler<EventoCanceladoEvent>>();
builder.RegisterType<RemoveConflitoService>().As<DomainEventHandler<ReservaDeLocalAlteradaEvent>>();
builder.RegisterType<RemoveConflitoService>().As<DomainEventHandler<HorarioDeEventoAlteradoEvent>>();
builder.Register<AgendaEventoService>(c => new AgendaEventoService(c.Resolve<Eventos>()));
builder.Register<TrocaSenhaService>(c => new TrocaSenhaService(c.Resolve<Usuarios>(), c.Resolve<UsuarioTokens>()));
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
IoCWorker.Initialize(resolver);
}
public static void Configure()
{
var builder = new ContainerBuilder();
builder.RegisterControllers(typeof(MvcApplication).Assembly);
builder.RegisterModelBinders(typeof(MvcApplication).Assembly);
builder
.Register(c => NHibernateConfig.SessionFactory.OpenSession())
.As<ISession>().InstancePerHttpRequest();
builder.RegisterType<CsvFileTextService<ForwardTextCandidate>>().As<ITextService<ForwardTextCandidate>>();
builder.RegisterType<CsvFileTextService<ReplyTextCandidate>>().As<ITextService<ReplyTextCandidate>>();
builder.RegisterType<Repository<ForwardTextCandidate>>().As<IBaseRepository<ForwardTextCandidate>>();
builder.RegisterType<Repository<ReplyTextCandidate>>().As<IBaseRepository<ReplyTextCandidate>>();
builder.Register<ServerStatusService>(c=>new ServerStatusService(NHibernateConfig.SessionFactory));
builder.RegisterType<UserService>();
builder.RegisterType<ServerProvidersAdminSettingsController>();
builder.RegisterType<UsersController>();
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Create the dependency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
// Configure Web API with the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
private HttpConfiguration BuildHttpConfigurations()
{
HttpConfiguration config = new HttpConfiguration();
//config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.Add(new JsonpMediaTypeFormatter());
config.MessageHandlers.Add(new CorsHandler(new CorsOptions()));
config.Formatters.XmlFormatter.UseXmlSerializer = false;
config.Formatters.JsonFormatter.UseDataContractJsonSerializer = true;
config.MapHttpAttributeRoutes();
var resolver = new AutofacWebApiDependencyResolver(BuildContainer());
config.DependencyResolver = resolver;
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(name: "GuitarApi",
routeTemplate: "api/Guitar/{action}",
defaults: new { controller = "Guitar", action = "{action}" });
return config;
}
public static void Configure()
{
var assemblies = BuildManager.GetReferencedAssemblies().Cast<Assembly>().ToArray();
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(assemblies)
.Where(t => typeof(IStartable).IsAssignableFrom(t))
.As<IStartable>()
.SingleInstance();
builder.RegisterAssemblyModules(assemblies);
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
var container = builder.Build();
// Set the dependency resolver for Web API.
var webApiResolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = webApiResolver;
// Set the dependency resolver for MVC.
var mvcResolver = new AutofacDependencyResolver(container);
DependencyResolver.SetResolver(mvcResolver);
}
private static void ConfigureAutofac(HttpConfiguration config, IIssueStore issueStore)
{
var builder = new ContainerBuilder();
if (issueStore == null)
{
builder.RegisterType<InMemoryIssueStore>()
.As<IIssueStore>()
.InstancePerLifetimeScope();
}
else
{
builder.RegisterInstance(issueStore);
}
builder.RegisterType<IssueStateFactory>()
.As<IStateFactory<Issue, IssueState>>()
.InstancePerLifetimeScope();
builder.RegisterType<IssueLinkFactory>()
.InstancePerLifetimeScope();
builder.RegisterHttpRequestMessage(config);
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
var container = builder.Build();
var resolver =
new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
}
public static void Initialize(Assembly webAssembly, IEnumerable<Assembly> relatedAssemblies)
{
var builder = new ContainerBuilder();
// register all of autofac modules
builder.RegisterAssemblyModules(relatedAssemblies.ToArray());
// register all controllers
builder.RegisterControllers(webAssembly);
// register all web api controllers
builder.RegisterApiControllers(webAssembly);
// register all filters
builder.RegisterFilterProvider();
// build up the container
var container = builder.Build();
// register it to ASP.NET MVC
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Create the dependency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
// Configure Web API with the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public static void RegisterContainer()
{
// Create the container builder.
var builder = new ContainerBuilder();
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.Register(db =>
{
var dbName = ConfigurationManager.AppSettings["dbName"];
return new MongoClient().GetServer().GetDatabase(dbName);
}).As<MongoDatabase>().InstancePerHttpRequest();
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)).InstancePerHttpRequest();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => t.Name.EndsWith("Service"))
.AsSelf().InstancePerHttpRequest();
// Build the container.
var container = builder.Build();
// Create the depenedency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
// Configure Web API with the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = resolver;
// Configure MVC with the dependency resolver.
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
protected void Application_Start(object sender, EventArgs e)
{
System.Web.Http.GlobalConfiguration.Configuration.Routes.MapHttpRoute("htt", "{controller}/{action}");
System.Web.Http.GlobalConfiguration.Configuration.Filters.Add(new HaishanExceptionHandler());
System.Web.Http.GlobalConfiguration.Configuration.Filters.Add(new HaishanActionFilter());
var flagIScoped = typeof(IScoped);
var flagITransient = typeof(ITransient);
var lstAssembly = System.Web.Compilation.BuildManager.GetReferencedAssemblies().Cast <System.Reflection.Assembly>().ToList();
var lstType = lstAssembly.SelectMany(x => x.GetTypes()).ToList();
var lstIScoped = lstType.Where(x => x != flagIScoped && flagIScoped.IsAssignableFrom(x)).ToArray();
var lstITransient = lstType.Where(x => x != flagITransient && flagITransient.IsAssignableFrom(x)).ToArray();
var builder = new Autofac.ContainerBuilder();
builder.RegisterTypes(lstIScoped).AsSelf().AsImplementedInterfaces().PropertiesAutowired()
.InstancePerApiRequest();
builder.RegisterTypes(lstITransient).AsSelf().AsImplementedInterfaces().PropertiesAutowired()
.InstancePerDependency();
var controllerAssembly = System.Reflection.Assembly.GetExecutingAssembly();
builder.RegisterApiControllers(controllerAssembly).AsSelf().PropertiesAutowired()
.InstancePerDependency();
var resolver = new Autofac.Integration.WebApi.AutofacWebApiDependencyResolver(builder.Build());
System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public static void Register(HttpConfiguration config)
{
// Create the container builder.
var builder = new ContainerBuilder();
// Register MVC 4 Contrrollers
builder.RegisterControllers(Assembly.GetExecutingAssembly());
// Register the Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
//register Domain Depedencies
builder.RegisterModule(new Domain.AutofacModule());
// Build the container.
var container = builder.Build();
// SET Web API resolver
// Create the depenedency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
// Configure Web API with the dependency resolver.
config.DependencyResolver = resolver;
//set MVC4 resolver
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
/// <summary>
/// Registers dependencies for Autofac to resolve via reflection at run-time.
/// </summary>
/// <exception cref="Exception"></exception>
public static void RegisterDependencies()
{
// Create the container builder.
var builder = new ContainerBuilder();
// Register the Web API controllers.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterWebApiFilterProvider(GlobalConfiguration.Configuration);
// Register your dependencies.
builder.RegisterType<UnitOfWork>().As<IUnitOfWork>();
builder.RegisterType<TekTak.iLoop.UOW.UnitOfWork>().As<TekTak.iLoop.UOW.IUnitOfWork>();
//builder.RegisterType<iLoopEntity>().InstancePerLifetimeScope();
ServiceRegister.Register(builder);
//RegisterJServices(builder);
AuthorizationRegister.Register(builder);
ValidatorRegister.Register(builder);
// Build the container.
var container = builder.Build();
// Create the dependency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
// Configure Web API with the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = resolver;
FluentValidation.WebApi.FluentValidationModelValidatorProvider.Configure(GlobalConfiguration.Configuration,
provider => provider.ValidatorFactory = new ValidatorFactory(container));
}
public static void Configure()
{
var builder = new ContainerBuilder();
builder.RegisterType<EFStoredGrantManager>().As<IStoredGrantManager>();
builder.RegisterType<DefaultAssertionGrantValidator>().As<IAssertionGrantValidation>();
builder.RegisterType<EFAuthorizationServerConfiguration>().As<IAuthorizationServerConfiguration>();
builder.RegisterType<EFAuthorizationServerAdministration>().As<IAuthorizationServerAdministration>();
builder.RegisterType<EFAuthorizationServerAdministratorsService>().As<IAuthorizationServerAdministratorsService>();
builder.RegisterType<AuthorizationServerContext>().InstancePerHttpRequest();
builder.RegisterType<TokenService>().AsSelf();
builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
builder.RegisterControllers(typeof(AuthorizeController).Assembly);
builder.RegisterControllers(typeof(AutofacConfig).Assembly);
builder.RegisterApiControllers(typeof(TokenController).Assembly);
builder.RegisterApiControllers(typeof(AutofacConfig).Assembly);
var container = builder.Build();
// MVC
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Web API
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
protected void DependencyInjectionConfiguration()
{
//Get all references assemblies
var coreAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var preferenceAssemblies = coreAssemblies.SelectMany(ca => ca.GetReferencedAssemblies());
// Load assemblies
var assemblies = coreAssemblies.Select(ca => ca.GetName())
.Union(preferenceAssemblies)
.Distinct()
.Select((Assembly.Load))
.ToArray();
var builder = new ContainerBuilder();
DependencyRegistrar.Register(builder, assemblies);
var container = builder.Build();
DependencyRegistrar.GlobalContainer = container;
// Register for MVC
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Register for ASP.NET Web API
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
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 static void Setup()
{
var builder = new ContainerBuilder();
builder.RegisterControllers(Assembly.GetExecutingAssembly());
// Register for API Controllers
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterModelBinders(Assembly.GetExecutingAssembly());
builder.RegisterFilterProvider();
builder.RegisterModelBinderProvider();
builder.RegisterModule<AutofacWebTypesModule>();
// Find all autofac modules and include them.
builder.RegisterModule<IdentityModule>();
// Find all IStartable tasks and register them.
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
builder.RegisterAssemblyTypes(assemblies)
.AssignableTo<IStartable>()
.As<IStartable>()
.SingleInstance();
// Enable property injection into action filters (including authorize attribute).
builder.RegisterFilterProvider();
IContainer container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
public void WrapperResolvesAuthenticationFilterFromDependencyScope()
{
var builder = new ContainerBuilder();
builder.Register<ILogger>(c => new Logger()).InstancePerDependency();
var activationCount = 0;
builder.Register<IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve<ILogger>()))
.AsWebApiAuthenticationFilterFor<TestController>(c => c.Get())
.InstancePerRequest()
.OnActivated(e => activationCount++);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var configuration = new HttpConfiguration { DependencyResolver = resolver };
var requestMessage = new HttpRequestMessage();
requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
var contollerContext = new HttpControllerContext { Request = requestMessage };
var controllerDescriptor = new HttpControllerDescriptor { ControllerType = typeof(TestController) };
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new AuthenticationFilterWrapper(metadata);
wrapper.OnAuthenticate(context);
Assert.That(activationCount, Is.EqualTo(1));
}
public static void Config()
{
var builder = new ContainerBuilder();
// Register dependencies in controllers
builder.RegisterControllers(typeof(MvcApplication).Assembly);
// Register dependencies in filter attributes
builder.RegisterFilterProvider();
// Register dependencies in custom views
builder.RegisterSource(new ViewRegistrationSource());
// Get your HttpConfiguration.
var config = GlobalConfiguration.Configuration;
// Register your Web API controllers.
builder.RegisterApiControllers(typeof(ReservationController).Assembly);
// OPTIONAL: Register the Autofac filter provider.
builder.RegisterWebApiFilterProvider(config);
builder.RegisterModule(new ManagerModule());
var container = builder.Build();
var webApiResolver = new AutofacWebApiDependencyResolver(container);
// Mechanism for setting the dependency resolver for Web API and MVC is different.
// Web API uses GlobalConfiguration.Configuration.DependencyResolver
GlobalConfiguration.Configuration.DependencyResolver = webApiResolver;
var mvcResolver = new AutofacDependencyResolver(container);
DependencyResolver.SetResolver(mvcResolver);
}
private static void SetAutofacWebAPIServices()
{
var configuration = GlobalConfiguration.Configuration;
var builder = new ContainerBuilder();
// Configure the container with the integration implementations.
builder.ConfigureWebApi(configuration);
builder.RegisterType<DigitalAccountsUnitOfWork>()
.As<IDigitalAccountsUnitOfWork>()
.InstancePerLifetimeScope();
builder.RegisterType<DigitalAccountsService>()
.As<IDigitalAccountsService>()
.InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(typeof(CuentaRepository).Assembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
// Register API controllers using assembly scanning.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
var container = builder.Build();
// Set the dependency resolver implementation.
var resolver = new AutofacWebApiDependencyResolver(container);
configuration.ServiceResolver.SetResolver(resolver);
AutofacServiceHostFactory.Container = container;
}
public async Task UriMaker_is_ctor_injected_using_Autofac()
{
var config = new HttpConfiguration();
// Autofac
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Web API routes
var uriMakerContext = config.MapHttpAttributeRoutesAndUseUriMaker();
builder.RegisterInstance(uriMakerContext).ExternallyOwned();
builder.RegisterHttpRequestMessage(config);
builder.RegisterGeneric(typeof(UriMaker<>)).AsSelf().InstancePerRequest();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
var client = new HttpClient(new HttpServer(config));
var res = await client.GetAsync("http://www.example.net/api/autofac/resources");
Assert.Equal(HttpStatusCode.OK,res.StatusCode);
var body = await res.Content.ReadAsAsync<ResourceState>();
Assert.Equal("http://www.example.net/api/autofac/resources", body.self.ToString());
Assert.Equal("http://www.example.net/api/autofac/resources?page=1&count=10", body.next.ToString());
Assert.Equal("http://www.example.net/api/autofac/resources/0", body.first.ToString());
Assert.Equal("http://www.example.net/api/autofac/resources/0?detailed=True", body.first_alternative.ToString());
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
Database.SetInitializer<MusicstoreContext>(null);
Database.SetInitializer(new CreateDatabaseIfNotExists<MusicstoreContext>());
Database.SetInitializer(new MigrateDatabaseToLatestVersion<MusicstoreContext,
Data.Migrations.Configuration>());
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
var builder = new ContainerBuilder();
#region data layer
//var dataSettingsManager = new DataSettingsManager();
//var dataProviderSettings = dataSettingsManager.LoadSettings();
#endregion
var db = new MusicstoreContext();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
//builder.RegisterGeneric(typeof(EfRepository<>)).AsImplementedInterfaces();
builder.Register<IRepository>(c => new EfRepository(db)).InstancePerApiRequest();
//builder.Register<IRepository<Artist>>(c => new EfRepository<Artist>(new MusicstoreContext())).InstancePerApiRequest();
//builder.Register<IRepository<Song>>(c => new EfRepository<Song>(new MusicstoreContext())).InstancePerApiRequest();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public static void RegisterResolver()
{
var resolver = new AutofacWebApiDependencyResolver(RegisterServices(new ContainerBuilder()));
// Configure Web API with the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public void Configuration(IAppBuilder app)
{
var listener = (HttpListener) app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemeSelectorDelegate = r =>
{
Log.InfoFormat("Request from {0}", r.RemoteEndPoint);
if (r.RemoteEndPoint != null && (_appSettings.IpAccessList.Contains(r.RemoteEndPoint.Address.ToString())))
{
Log.InfoFormat("Ip listed, applying {0} authentication scheme", AuthenticationSchemes.Anonymous);
return AuthenticationSchemes.Anonymous;
}
Log.InfoFormat("Ip unknown, applying {0} authentication scheme", AuthenticationSchemes.IntegratedWindowsAuthentication);
return AuthenticationSchemes.IntegratedWindowsAuthentication;
};
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).InstancePerRequest();
builder.RegisterInstance(new DeployOption(_appSettings.InstallPath)).As<IDeployOption>();
; var container = builder.Build();
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
app.UseAutofacMiddleware(container);
app.UseWebApi(config);
}
private static void RegisterWebApi(Assembly[] assemblies)
{
var configuration = GlobalConfiguration.Configuration;
var builder = CreateContainerBuilder();
builder.RegisterWebApiFilterProvider(configuration);
builder.RegisterWebApiModelBinders(assemblies);
builder.RegisterApiControllers(assemblies);
var container = builder.Build();
var resolver = new WebApiResolver(container);
configuration.DependencyResolver = resolver;
}
