private static IMediator BuildMediator() { var container = new UnityContainer(); container.RegisterTypes(AllClasses.FromAssemblies(typeof (Ping).Assembly), WithMappings.FromAllInterfaces); container.RegisterTypes(AllClasses.FromAssemblies(typeof (IMediator).Assembly), WithMappings.FromAllInterfaces); container.RegisterInstance(Console.Out); var serviceLocator = new UnityServiceLocator(container); var serviceLocatorProvider = new ServiceLocatorProvider(() => serviceLocator); container.RegisterInstance(serviceLocatorProvider); var mediator = container.Resolve<IMediator>(); return mediator; }
public static void Register(HttpConfiguration config) { var container = new UnityContainer(); var applicationDbContext = new ApplicationDatabaseContext(); var userStore = new UserStore<Person>(applicationDbContext); container.RegisterInstance( typeof(ApplicationDatabaseContext), applicationDbContext); container.RegisterTypes( AllClasses.FromLoadedAssemblies() .Where( type => (typeof(IManager).IsAssignableFrom(type) || typeof(IStore).IsAssignableFrom(type)) && !type.IsAbstract && !type.IsInterface), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.PerResolve); container.RegisterType<IEmailManager, EmailManager>(); var userManager = AuthConfig.ConfigureUserManager(userStore, null); container.RegisterInstance(typeof(UserManager<Person>), userManager); container.RegisterInstance(typeof(IUserStore<Person>), userStore); // Web API configuration and services config.DependencyResolver = new UnityDependencyResolver(container); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public UnityTests() { var container = new UnityContainer(); container.RegisterTypes(AllClasses.FromAssemblies(typeof(A).Assembly), WithMappings.FromAllInterfaces, overwriteExistingMappings: true); ServiceLocator = new UnityServiceLocator(container); }
public static void RegisterComponents() { var container = new UnityContainer(); container.RegisterType<IVeteranService, VeteranService>(); container.RegisterType<IUserService, UserService>(new HierarchicalLifetimeManager()); container.RegisterType<IImageVeteranService, ImageVeteranService>(new HierarchicalLifetimeManager()); container.RegisterType<IArticleService, ArticleService>(); container.RegisterType<IComment, ArticleService>("ArticleServiceComment"); container.RegisterType<ICommentService, CommentService>(new HierarchicalLifetimeManager()); container.RegisterType<IPhotoAlbumService, PhotoAlbumService>(new HierarchicalLifetimeManager()); container.RegisterType<IDatabaseFactory, DatabaseFactory>(new HierarchicalLifetimeManager()); container.RegisterType<IUnitOfWork, UnitOfWork>(new HierarchicalLifetimeManager()); container.RegisterType(typeof(IRepository<>), typeof(Repository<>)); container.RegisterType<IImageService, ImageService>(); container.RegisterType(typeof(IFormService<>), typeof(FormService<>)); container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(t => t.BaseType == typeof(SpecificationBase<>)), WithMappings.FromMatchingInterface, WithName.Default); // TODO: Register your types here container.RegisterType<IUserStore<User>, UserStore<User>>(); container.RegisterType<UserManager<User>>(); container.RegisterType<User>(); container.RegisterType<DbContext, ApplicationDbContext>(); container.RegisterType<ApplicationUserManager>(); container.RegisterType<AccountController>(new InjectionConstructor(typeof(ApplicationUserManager),typeof(IUserService))); GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container); GlobalHost.DependencyResolver = new SignalRUnityDependencyResolver(container); container.RegisterType<CommentHub>(new InjectionFactory(CreateCommentHub)); }
public static IUnityContainer CreateUnityContainer() { var container = new UnityContainer(); container.RegisterType<IMediator, Mediator>(); var types = AllClasses.FromAssemblies( typeof( Program ).Assembly ); container.RegisterTypes( types, WithMappings.FromAllInterfaces, GetName, GetLifetimeManager, null, true ); container.RegisterInstance<SingleInstanceFactory>( t => { var pipeline = container.Resolve( typeof( MediatorPipeline<,> ).MakeGenericType( t.GetGenericArguments() ) ); return pipeline; } ); container.RegisterInstance<MultiInstanceFactory>( t => container.ResolveAll( t ) ); return container; }
public static void RegisterComponents() { var container = new UnityContainer(); var applicationDataAssembly = AppDomain.CurrentDomain.GetAssemblies() .First(a => a.FullName == "Application.Data, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"); container.RegisterType<ApplicationDbContext>(new PerResolveLifetimeManager()); container.RegisterTypes(applicationDataAssembly.GetTypes(), WithMappings.FromMatchingInterface, WithName.Default); container.RegisterType<IAuthenticationManager>( new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication)); container.RegisterType<IUserStore<ApplicationUser>, UserStore<ApplicationUser>>( new InjectionConstructor(typeof(ApplicationDbContext))); container.RegisterType<IRoleStore<ApplicationRole, string>, RoleStore<ApplicationRole, string, IdentityUserRole>>( new InjectionConstructor(typeof(ApplicationDbContext))); DependencyResolver.SetResolver(new UnityDependencyResolver(container)); }
private static IUnityContainer ConfigureContainer(IServiceProvider package, ServiceLocatorOptions options) { if (package == null) throw new ArgumentNullException(nameof(package), $"{nameof(package)} is null."); IUnityContainer container = new UnityContainer(); container.AddExtension(new ServiceProviderUnityExtension(package, options)); container.RegisterType<IToolkit, TookitImpl>(new ContainerControlledLifetimeManager()); container.RegisterTypes(new SolutionExplorerNodeFactoryRegistrationConvention()); container.RegisterType<IEnumerable<ISolutionExplorerNodeFactory>, ISolutionExplorerNodeFactory[]>(); container.RegisterType<ISolutionExplorerNodeFactory, GlobalSolutionExplorerNodeFactory>(); container.RegisterType<ISolutionExplorer, SolutionExplorer>(); container.RegisterType<IOutputWindow, OutputWindow>(new ContainerControlledLifetimeManager()); container.RegisterType<IDialogService, DialogService>(new ContainerControlledLifetimeManager()); container.RegisterType<IEnumerable<ICommandImplementation>, ICommandImplementation[]>(); container.RegisterInstance<IServiceProvider>(package); container.RegisterType<ICommandManager, CommandManager>(new ContainerControlledLifetimeManager()); UnityServiceLocator serviceLocator = new UnityServiceLocator(container); container.RegisterInstance<IServiceLocator>(serviceLocator); if (!ServiceLocator.IsLocationProviderSet) ServiceLocator.SetLocatorProvider(() => serviceLocator); return container; }
public static void RegisterComponents(HttpConfiguration configuration) { // create a Unity container var container = new UnityContainer(); // create an AutoMapper configuration var mapperConfiguration = DtoMapperConfiguration.Build(); // register dependencies by convention // this will register all classes with matching interfaces in loaded assemblies (in a real world app you might want to be more explicit on assemblies to scan) container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default); // register a dependency, in this case a mapping from the greeting repository interface to the greeting repository implementation // convention based registraton above will have already done this, shown explicitly here for demo purposes container.RegisterType<IGreetingRepository, GreetingRepository>(); // here we are registering AutoMapper and controlling how Unity creates the instance by specifying an injection factory container.RegisterType<IMapper>("dtoMapper", new InjectionFactory(x => mapperConfiguration.CreateMapper())); // Web API has built in support for dependency injection by setting the DependencyResolver property on the configuration object // here we register the Unity container with Web API as a dependency resolver configuration.DependencyResolver = new UnityDependencyResolver(container); }
internal static void Configure(UnityContainer container) { container.RegisterTypes (FromTypes(), FromMachingInterfaces, WithName.Default, WithLifetime.ContainerControlled); }
private static void RegisterUnityContainer(HttpConfiguration config) { var container = new UnityContainer(); container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.FromAllInterfaces, WithName.TypeName, WithLifetime.Transient); config.DependencyResolver = new UnityResolver(container); //config.Filters.Add(new UnhandledExceptionFilter()); }
public static UnityContainer RegisterTypes() { var container = new UnityContainer(); container.RegisterTypes(AllClasses.FromAssemblies(true, LoadAssemblies()), WithMappings.FromMatchingInterface, WithName.Default, PerRequest); return container; }
public void WhenRegisteringFromLoadedTypes() { IUnityContainer container = new UnityContainer(); container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromAllInterfaces, WithName.TypeName, null, null, true); foreach (var registration in container.Registrations) { if (registration.Name == null) { continue; } Assert.IsFalse(registration.Name.Contains("TypeInAssemblyToLoad")); } Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "\\AssemblyToLoad.dll"); container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromAllInterfaces, WithName.TypeName, null, null, true); bool found = false; foreach (var registration in container.Registrations) { if (registration.Name == null) { continue; } if (registration.Name.Contains("TypeInAssemblyToLoad")) { found = true; } } Assert.IsTrue(found); }
public static void RegisterComponents() { var container = new UnityContainer(); var allClasses = AllClasses.FromAssemblies(BuildManager.GetReferencedAssemblies().Cast<Assembly>()); container.RegisterTypes(allClasses, WithMappings.FromMatchingInterface, WithName.Default); container.AddNewExtension<MapsContainerExtension>(); GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container); }
public static IUnityContainer RegisterComponents() { var container = new UnityContainer(); // Register all repository classes automatically // Register all service classes automatically in the business layer container.RegisterTypes( AllClasses.FromAssemblies(new[] { Assembly.Load("Neemo"), Assembly.Load("Neemo.CarParts"), Assembly.Load("Neemo.CarParts.EntityFramework"), }), WithMappings.FromMatchingInterface, WithName.Default); // Register ilogger with log4net container.RegisterType<ILogger, Log4NetLog>(); // Register the PayPal payment service ( later we may have a few more :) container.RegisterType<Payments.IPaymentService, Payments.pp.PaymentService>(); // FileStore image service requires http utility to initialise container.RegisterType<Images.IImageService, Images.FileImageService>(new InjectionConstructor(HttpContext.Current.Server.MapPath("~/"), typeof(ISysConfig))); // ICartContext (session based) container.RegisterType<ShoppingCart.ICartContext, Infrastructure.SessionCartContext>(); // Services in website/infrastructure ( including the local mapping config ) container.RegisterType<Infrastructure.ITemplateService, Infrastructure.TemplateService>(); container.RegisterType<Shipping.IShippingCalculatorService, Infrastructure.ShippingService>(); // Register all the assemblies that use the IMapping Config container.RegisterType<IMappingConfig, MappingConfig>("WebConfig"); container.RegisterTypes(new RegisterMappersConvention("Neemo.CarParts.EntityFramework", "Neemo.Payments.PayPal")); // Set the MVC dependency resolver to use Unity! DependencyResolver.SetResolver(new UnityDependencyResolver(container)); return container; }
public void WhenRegisteringMappedInterfacesFromAnAssemblyWithTypeNamesInterfaceRegistrationNameIsNotMismatched2() { IUnityContainer container = new UnityContainer(); container.RegisterTypes( AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))), WithMappings.FromAllInterfacesInSameAssembly, WithName.TypeName, null); AssertHelper.ThrowsException<ResolutionFailedException>(() => container.Resolve<IInterface2>("TypeImplementingI1")); }
internal static IUnityContainer BuildMediator() { var container = new UnityContainer(); container.RegisterType<IMediator, Mediator>(); container.RegisterTypes(AllClasses.FromAssemblies(typeof(Ping).Assembly), WithMappings.FromAllInterfaces, GetName, GetLifetimeManager); container.RegisterType(typeof(INotificationHandler<>), typeof(GenericHandler), GetName(typeof(GenericHandler))); container.RegisterType(typeof(IAsyncNotificationHandler<>), typeof(GenericAsyncHandler), GetName(typeof(GenericAsyncHandler))); container.RegisterInstance(Console.Out); container.RegisterInstance<SingleInstanceFactory>(t => container.Resolve(t)); container.RegisterInstance<MultiInstanceFactory>(t => container.ResolveAll(t)); return container; }
public IDependencyResolver Register() { var container = new UnityContainer(); container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default); container.RegisterType<ICompanyQuery, CompanyQuery>(new ContainerControlledLifetimeManager()); return new UnityDependencyResolver(container); }
public void InitializeDependencies() { var IoCcontainer = new UnityContainer(); IoCcontainer.RegisterTypes( AllClasses.FromAssembliesInBasePath(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.ContainerControlled); IoCcontainer.LoadConfiguration(); //Gets the resolution root commandHandler = IoCcontainer.Resolve<ICommandHandler>(); }
public static void Register(HttpConfiguration config) { var unityContainer = new UnityContainer(); unityContainer.RegisterInstance<DataService>(new DataService()); unityContainer.RegisterTypes( AllClasses.FromLoadedAssemblies().Where(t => t.IsAssignableFrom(typeof(IHttpController))), WithMappings.FromAllInterfaces); config.DependencyResolver = new UnityDependencyResolver(unityContainer); config.MapHttpAttributeRoutes(); config.Services.Replace(typeof(IExceptionHandler),new GlobalErrorHandlerService()); config.MessageHandlers.Add(new ErrorHandlerMessageHandler()); config.MessageHandlers.Add(new BufferNonStreamedContentHandler()); config.EnableSystemDiagnosticsTracing(); }
public static void Resolve(UnityContainer container) { // Mapeamento padrão para todas as interfaces e implementações // que seguem o padrão INomeConcreto/NomeConcreto container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient); // Entidades que não possuem o mesmo nome da interface apenas acrescentando o I como prefixo // Ex.: PedidoRepositoryEf implementa a interface IPedidoRepository container.RegisterType<IPedidoRepository, PedidoRepositoryEf>(); container.RegisterType<IItemPedidoRepository, ItemPedidoRepositoryEf>(); }
public static IUnityContainer GetContainer() { IUnityContainer container = new UnityContainer(); container.RegisterTypes( AllClasses.FromAssembliesInBasePath(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.ContainerControlled, overwriteExistingMappings:true); // Manual Mappings container.RegisterType<IConversationRepository, Data.EntityFramework.Conversations.ConversationRepository>(); return container; }
public void WhenSomeTypesCannotBeLoadedAndSkipFlagIsFalse() { IUnityContainer container = new UnityContainer(); AssertHelper.ThrowsException<DuplicateTypeMappingException>(() => { return container.RegisterTypes( AllClasses.FromAssembliesInBasePath(false, false), WithMappings.FromAllInterfaces, WithName.TypeName, null, null, false); }); }
private void OnApplicationStartup(object sender, StartupEventArgs e) { CreateMappings(); container = new UnityContainer(); container.RegisterTypes( AllClasses.FromAssembliesInBasePath(), WithMappings.FromMatchingInterface, WithName.Default ); MainWindow = container.Resolve<TaskListView>(); MainWindow.Show(); ((TaskListController)MainWindow.DataContext).OnLoad(); }
public static IUnityContainer RegisterComponents(HttpConfiguration config) { var container = new UnityContainer(); //container.RegisterType<IAuthentication, Authentication>(); //container.RegisterType<IArticleManager, ArticleManager>(); //container.RegisterType<IArticleRepository, ArticleRepository>(); //container.RegisterType<INewsPortalContext, NewsPortalContext>(); container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.None); config.DependencyResolver = new UnityDependencyResolver(container); return container; }
private static UnityContainer RegisterUnityRootContainer() { var container = new UnityContainer(); container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Hierarchical); container.RegisterType<IRepository, EntityRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IAccountService, AccountService>(new HierarchicalLifetimeManager()); container.RegisterType<IWidgetService, WidgetService>(new HierarchicalLifetimeManager()); return container; }
private void OnApplicationStartup(object sender, StartupEventArgs e) { CreateMappings(); container = new UnityContainer(); container.RegisterTypes( AllClasses.FromAssembliesInBasePath().Where(type => type.Assembly.FullName.StartsWith(MatchingAssemblyPrefix)), UserDefinedInterfaces, WithName.Default ); MainWindow = container.Resolve<TaskListView>(); MainWindow.Show(); ((TaskListController)MainWindow.DataContext).OnLoad(); }
public static void RegisterComponents() { Container = new UnityContainer(); // register all your components with the container here // it is NOT necessary to register your controllers Container .RegisterType<IUnitOfWork, UnitOfWork>(); Container.RegisterTypes( AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Hierarchical); GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(Container); }
public void WhenMultipleMappingsToSameInterfaceLastOneWinsWins() { IUnityContainer container = new UnityContainer(); container.RegisterTypes( AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))), WithMappings.FromAllInterfacesInSameAssembly, WithName.Default, null, null, true); var resolved1 = container.Resolve<ITypeImplementingI1>(); var resolved2 = container.Resolve<IInterface2>(); Assert.IsInstanceOfType(resolved1, typeof(TypeImplementingI12)); Assert.IsInstanceOfType(resolved2, typeof(TypeImplementingI12)); }
private static IUnityContainer BuildUnityContainer() { UnityContainer container = new UnityContainer(); container.RegisterTypes( AllClasses.FromLoadedAssemblies().Where(t => t.Namespace != null && t.Namespace.Contains("CSN.Business")), WithMappings.FromMatchingInterface, WithName.Default //, //WithLifetime.ContainerControlled ); // register all your components with the container here // it is NOT necessary to register your controllers // e.g. container.RegisterType<ITestService, TestService>(); return container; }
public void CanResolveMappedInterfacesFromAnAssemblyWithTypeNames() { IUnityContainer container = new UnityContainer(); container.RegisterTypes(AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))), WithMappings.FromAllInterfacesInSameAssembly, WithName.TypeName, null); var resolved1 = container.Resolve<ITypeImplementingI1>("TypeImplementingI1"); var resolved2 = container.Resolve<IInterface2>("TypeImplementingI2"); var resolved3 = container.Resolve<ITypeImplementingI1>("TypeImplementingI12"); var resolved4 = container.Resolve<IInterface2>("TypeImplementingI12"); Assert.IsInstanceOfType(resolved1, typeof(TypeImplementingI1)); Assert.IsInstanceOfType(resolved2, typeof(TypeImplementingI2)); Assert.IsInstanceOfType(resolved3, typeof(TypeImplementingI12)); Assert.IsInstanceOfType(resolved4, typeof(TypeImplementingI12)); }