private void SetUpDbSettings() { if (!Program.Container.Kernel.HasComponent(typeof(DatabaseSettings))) { var dbSettings = new DatabaseSettings { Url = tbDbUrl.Text, UserName = tbDdUserName.Text, Password = tbDbPassword.Text }; Program.Container.Register(Component.For <DatabaseSettings>().Instance(dbSettings)); } else { var currentXmlApiSettings = Program.Container.Resolve <DatabaseSettings>(); currentXmlApiSettings.Url = tbDbUrl.Text; currentXmlApiSettings.UserName = tbDdUserName.Text; currentXmlApiSettings.Password = tbDbPassword.Text; } IDbProvider dbProvider = rbSqlProvider.Checked ? (IDbProvider) new SqlProvider() : new OracleProvider(); if (!Program.Container.Kernel.HasComponent(typeof(IDataContext))) { var dataContext = new DapperDataContext(Program.Container.Resolve <DatabaseSettings>(), dbProvider); Program.Container.Register(Component.For <IDataContext>().Instance(dataContext)); } else { var currentXmlApiSettings = Program.Container.Resolve <IDataContext>(); currentXmlApiSettings.DbProvider = dbProvider; } }
protected override void Arrange() { AssemblyLoader.EnsureLoaded <Marker_EdFi_Ods_Test_TestExtension>(); AssemblyLoader.EnsureLoaded <Marker_EdFi_Ods_Standard>(); _container = new WindsorContainerEx(); _container.Register( Component .For <IResourceModelProvider>() .ImplementedBy <ResourceModelProvider>()); _container.Register( Component.For <IExtensionNHibernateConfigurationProvider>() .ImplementedBy <ExtensionNHibernateConfigurationProvider>()); _container.Register( Component.For <IFilterCriteriaApplicatorProvider>() .ImplementedBy <FilterCriteriaApplicatorProvider>()); _container.Register(Component.For <IOrmMappingFileDataProvider>() .UsingFactoryMethod(kernel => new OrmMappingFileDataProvider(kernel.Resolve <IAssembliesProvider>(), DatabaseEngine.SqlServer, "EdFi.Ods.Standard")) ); _container.Register(Component.For <IAssembliesProvider>().ImplementedBy <AssembliesProvider>()); }
public static IWindsorContainer RegisterType <TServiceType, TClassType>(this IWindsorContainer container, string name) where TClassType : TServiceType { return(container.Register(Component.For(typeof(TServiceType)) .ImplementedBy(typeof(TClassType)) .Named(name) .LifeStyle.Transient)); }
public void RegisterDbSetTypes() { var method = this.GetType().GetMethods().First(m => m.IsGenericMethod && m.Name == "Set"); foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { try { var entityTypes = assembly.GetTypes().Where(this.IsTypePersistent); foreach (var type in entityTypes) { try { var generic = method.MakeGenericMethod(type); var dbSet = generic.Invoke(this, null); var dbSetType = typeof(DbSet <>).MakeGenericType(type); this.WindsorContainer.Register(Component.For(dbSetType).LifestyleSingleton().Instance(dbSet).OnlyNewServices()); } catch (Exception ex) { Debug.WriteLine(ex); } } } catch (Exception ex) { Debug.WriteLine(ex); } } }
protected override void ConfigureWindsorContainer() { container.AddFacility <FactorySupportFacility>(); container.Register(Component.For <CommonPropertyStoreInterceptor>() .LifeStyle.Transient); container.Register(Component.For <EntityNameInterceptor>() .LifeStyle.Transient); container.Register(Component.For <CollectionPropertyInterceptor>() .LifeStyle.Transient); container.Register(Component.For <PropertyChangeInterceptor>() .LifeStyle.Transient); container.Register(Component.For <Store>() .Interceptors(new InterceptorReference( typeof(CollectionPropertyInterceptor))).Anywhere .ImplementedBy <Store>() .EnableNhibernateEntityCompatibility() .LifeStyle.Transient); container.Register(Component.For <IStore>() .UsingFactoryMethod(kernel => kernel.Resolve <Store>()) .LifeStyle.Transient); container.Register(Component.For <IProduct>() .TargetIsCommonDatastore().LifeStyle.Transient); }
private void InitFacility() { Kernel.Register( Component .For <TypedFactoryInterceptor>() .NamedAutomatically(InterceptorKey)); if (!disableDelegateFactory) { Kernel.Register( Component .For <ILazyComponentLoader>() .ImplementedBy <DelegateFactory>() .NamedAutomatically(DelegateFactoryKey)); } Kernel.Register( Component .For <ITypedFactoryComponentSelector>() .ImplementedBy <DefaultTypedFactoryComponentSelector>() .NamedAutomatically(DefaultInterfaceSelectorKey)); Kernel.Register( Component .For <ITypedFactoryComponentSelector>() .ImplementedBy <DefaultDelegateComponentSelector>() .NamedAutomatically(DefaultDelegateSelectorKey)); Kernel.ComponentModelBuilder.AddContributor(new TypedFactoryCachingInspector()); }
public void RegisterVirtualizingObservableDBSetPagedCollections() { foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { try { var entityTypes = assembly.GetTypes().Where(this.IsTypePersistent); foreach (var type in entityTypes) { try { var dbSetType = typeof(VirtualizingObservableDBSetPagedCollection <>).MakeGenericType(type); //this.WindsorContainer.Register(Component.For(dbSetType).LifestyleSingleton().OnlyNewServices()); this.WindsorContainer.Register(Component.For(dbSetType).LifestyleTransient()); //Has to be transparent otherwise it cannot dynamically load appropriete items by filter } catch (Exception ex) { Debug.WriteLine(ex); } } } catch (Exception ex) { Debug.WriteLine(ex); } } }
/// <summary> /// Registers the theClassType on the container. /// </summary> /// <typeparam name="TServiceType">The theClassType of interface.</typeparam> /// <typeparam name="TClassType">The theClassType of the service.</typeparam> /// <param name="container">The container.</param> /// <param name="singleton">if set to <c>true</c> theClassType will be registered as singleton.</param> public static void RegisterType <TServiceType, TClassType>(this IWindsorContainer container, bool singleton) { if (!container.Kernel.HasComponent(typeof(TServiceType))) { var serviceType = container.TryResolve(typeof(TServiceType)); if (serviceType == null && !singleton) { container.Register(Component.For(typeof(TServiceType)) .ImplementedBy(typeof(TClassType)) .LifeStyle.Transient); } if (singleton) { if (serviceType == null) { container.Register(Component.For(typeof(TServiceType)) .ImplementedBy(typeof(TClassType)) .LifeStyle.Singleton); } } //container.Kernel.AddComponent(typeof(TClassType).FullName, typeof(TServiceType), typeof(TClassType), singleton ? LifestyleType.Singleton : LifestyleType.Transient); } }
private void EnsureFactoryIsRegistered(string factoryId, Type factoryType) { if (!Kernel.HasComponent(factoryType)) { Kernel.Register(Component.For(factoryType).Named(factoryId)); } }
/// <summary> /// Handles solution registrations. /// </summary> /// <param name="layerName">Base namespace in project.</param> /// <param name="includes">Files to be included.</param> /// <param name="contents">Content to be included.</param> /// <param name="files">All files in project.</param> /// <param name="projectType">Type of project.</param> /// <param name="nugets">Nugets to be referenced.</param> /// <param name="imports">Projects to be referenced.</param> /// <param name="container">Container where to register project files.</param> public static void RegisterSolutionLayer(string layerName, ProjectType projectType, List <PackageConfigInfo> nugets, List <IGenerableFile> files, List <IGenerableFile> includes, List <ContentInfo> contents, List <AssemblyBase> imports, WindsorContainer container) { IAssembly instance; switch (projectType) { case ProjectType.Console: instance = MakeConsoleProject(layerName, layerName, includes, contents, files, nugets, imports); break; case ProjectType.Library: instance = MakeLibraryProject(layerName, layerName, includes, contents, files, nugets, imports); break; case ProjectType.WebApi: instance = MakeWebApiProject(layerName, layerName, includes, contents, files, nugets, imports); break; default: throw new NotSupportedException("This type of project is not supported"); } container.Register( Component.For <IAssembly>().Instance(instance ).Named(layerName)); }
private void LegacyInit() { Kernel.Register(Component.For <FactoryInterceptor>().NamedAutomatically("typed.fac.interceptor")); var converter = Kernel.GetConversionManager(); AddFactories(FacilityConfig, converter); }
/// <summary> /// /// </summary> /// <param name="container"></param> /// <param name="type"></param> /// <param name="instance"></param> /// <param name="name"></param> /// <returns></returns> public static IWindsorContainer RegisterInstance <TService, TClassType>(this IWindsorContainer container, object instance, string name = null) where TService : class where TClassType : class { return(container.Register(Component.For(typeof(TService)) .ImplementedBy(typeof(TClassType)) .Instance(instance) .LifeStyle.Transient)); }
//Resolver to map my interfaces with my implementations //that should be called in the main method of the application. private static void Resolver() { _container = new WindsorContainer(); _container.Register(Component.For <IFood>().ImplementedBy <FrenchCuisine>()); _container.Register(Component.For <IFood>().ImplementedBy <ComidaBrasileira>()); _container.Register( Component.For <ITranslate>().ImplementedBy <FrenchTranslator>().DependsOn(new FrenchCuisine())); }
// This method gets called by the runtime. Use this method to add services to the container. public IServiceProvider ConfigureServices(IServiceCollection services) { _container.CrossWiresInto(services); _container.Register(Component.For <IHttpContextAccessor>().ImplementedBy <HttpContextAccessor>()); _container.Register(Component.For <IScopeSomething>().ImplementedBy <ScopeSomething>().LifestyleScoped().CrossWired().IsDefault()); services.AddMvc(); return(services.AddWindsor(_container)); }
/// <summary> /// Setup the IoC container and register needed types /// </summary> private void SetupContainer() { this.Container = new WindsorContainer(); this.Container.Register(Component.For <IWindsorContainer>().Instance(this.Container)); BooReader.Read(this.Container, "Global.boo"); }
/// <summary> /// Resolves a service from the container. If the theClassType does not exist on the container, /// first registers it with transient lifestyle. /// </summary> /// <param name="container"></param> /// <param name="theClassType"></param> /// <returns></returns> public static object Resolve(this IWindsorContainer container, Type theClassType) { if (theClassType.IsClass && !container.Kernel.HasComponent(theClassType)) { container.Register(Component.For(theClassType).Named(theClassType.FullName).LifeStyle.Transient); } return(container.Resolve(theClassType)); }
/// <summary> /// /// </summary> /// <param name="windsorContainer"></param> /// <param name="serviceType"></param> /// <returns></returns> internal static object Resolve(IWindsorContainer windsorContainer, Type serviceType) { if (serviceType.IsClass && !windsorContainer.Kernel.HasComponent(serviceType)) { windsorContainer.Register(Component.For(serviceType).Named(serviceType.FullName).LifeStyle.Transient); } return(windsorContainer.Resolve(serviceType)); }
public MvcControllerBuilderFactoryTest() { // LocalIocManager.Register<MvcControllerManager>(); LocalIocManager.IocContainer.Register(Component.For <MvcControllerManager>()); this.servicesType = LocalIocManager.IocContainer.Kernel.GetHandlers().SelectMany(t => t.Services).Where(t => t.Assembly == Assembly.GetExecutingAssembly()); }
protected override void ConfigureContainer() { base.ConfigureContainer(); Container.Register( Component.For(typeof(ISagaPersister <>)) .ImplementedBy(typeof(InMemorySagaPersister <>)) ); }
protected override void ConfigureWindsorContainer() { container.AddFacility <FactorySupportFacility>(); container.AddFacility <ComponentBehaviorsFacility>(); var config = new BehaviorDictionary(); config.For <Album>().Add <NotifyPropertyChangedBehavior>().Add <EditableBehavior>(); container.Register(Component.For <IBehaviorStore>().Instance(config)); }
public ComponentReference(Type service) { _name = service.FullName; if (kernel.HasComponent(_name) == false) { kernel.Register(ComponentReg.For(service).Named(_name)); } }
protected override void ConfigureContainer() { base.ConfigureContainer(); Container.Register( Component.For <IMessageModule>() .ImplementedBy <EchoMessageModule>() .Named("Echo")); }
public Form1() { IWindsorContainer container = new WindsorContainer(); // Register the CompositionRoot type with the container container.Register(Component.For <ITemp>().ImplementedBy <Temp>()); var root = container.Resolve <ITemp>(); int fgh = root.add(2, 3); InitializeComponent(); }
void IContainer.RegisterService <I, T>(string key, ServiceLifetime lifetime) { var registration = Component.For <I>().ImplementedBy <T>(); if (!string.IsNullOrEmpty(key)) { registration = registration.Named(key); } windsorContainer.Register(registration.LifeStyle.Is(GetLifestyle(lifetime))); }
public static void Initialize() { Container=new WindsorContainer(); Container.Register(Component.For<IInterceptor>().ImplementedBy<OrderProcessorInterceptor>()); Container.Register( Component.For<IOrderProcessor>() .ImplementedBy<OrderProcessor>() .Interceptors(InterceptorReference.ForType<OrderProcessorInterceptor>()) .Anywhere); }
private static void SetupUrlShortener(GlobalConfiguration globalConfiguration, WindsorContainer container) { var primary = Type.GetType(globalConfiguration.General.UrlShortener); var secondary = globalConfiguration.General.SecondaryUrlShortener != null ? Type.GetType(globalConfiguration.General.SecondaryUrlShortener) : null; container.Register( Component.For <IUrlShorteningService>().ImplementedBy(primary), Component.For <IUrlShorteningService>().ImplementedBy(secondary).Named("secondaryShortener") ); }
private void RegisterNHibernateConfigurationActivities(IWindsorContainer container) { container.Register( Component .For <INHibernateBeforeBindMappingActivity>() .ImplementedBy <OwnershipBasedAuthorizationNHibernateConfigurationActivity>()); container.Register( Component .For(typeof(ICreateEntity <>)) .ImplementedBy(typeof(OwnershipInitializationCreateEntityDecorator <>)).IsDecorator()); }
protected override void GivenIRegister() { this.Sut.Register( Component .For <LoggingInterceptor>() .LifeStyle.Transient, Component .For <IMovie>() .ImplementedBy <NHMovie>() .Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere .LifeStyle.Transient ); }
protected override void GivenIRegister() { this.Sut.Register( Component .For <NotifyPropertyChangedInterceptor>() .LifeStyle.Transient, Component .For <IMovieViewModel>() .ImplementedBy <MovieViewModel>() .Interceptors(InterceptorReference.ForType <NotifyPropertyChangedInterceptor>()).Anywhere .LifeStyle.Transient ); }
public void SetUp() { container.Register(Component.For <IReader>().ImplementedBy <TXTReader>()); container.Register(Component.For <ISaver>().ImplementedBy <PNGSaver>()); container.Register(Component.For <IWordKeeper>() .ImplementedBy <StandartWordKeeper>() .DependsOn(new { delimiters = new [] { "\n" } }) .LifeStyle.Transient); container.Register(Component.For <ICloudLayouter>() .ImplementedBy <CircularCloudLayouter>() .DependsOn(new { pointCenter = new Point(0, 0) }) .LifeStyle.Transient); }