Example #1
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var documentStore = new DocumentStore { ConnectionStringName = "Raven" };
            documentStore.Initialize();

            container.Register(Component.For<IDocumentStore>().Instance(documentStore).LifeStyle.Singleton);
        }
		public void Init()
		{
			container = new WindsorContainer();

			store = (IConfigurationStore) 
				container.Kernel.GetSubSystem(SubSystemConstants.ConfigurationStoreKey);
		}
Example #3
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     Console.WriteLine("Running installer for SimpleSaga");
     container.Register(
         Component.For<ISaga>().ImplementedBy<TestSaga>().LifeStyle.Singleton
         );
 }
Example #4
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(Component.For<IStudentService>()
            .ImplementedBy<StudentService>()
            .LifestyleTransient());

            container.Register(Component.For<IGroupService>()
            .ImplementedBy<GroupService>()
            .LifestyleTransient());

            container.Register(Component.For<IDepartmentService>()
            .ImplementedBy<DepartmentService>()
            .LifestyleTransient());

            container.Register(Component.For<IPositionService>()
            .ImplementedBy<PositionService>()
            .LifestyleTransient());

            container.Register(Component.For<ITeacherService>()
            .ImplementedBy<TeacherService>()
            .LifestyleTransient());

            container.Register(Component.For<ICourseService>()
            .ImplementedBy<CourseService>()
            .LifestyleTransient());

            container.Register(Component.For<IScheduleService>()
            .ImplementedBy<ScheduleService>()
            .LifestyleTransient());

            container.Register(Component.For<IAcademicProgressService>()
            .ImplementedBy<AcademicProgressService>()
            .LifestyleTransient());
        }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         AllTypes.FromAssemblyNamed("SharpArchTemplate.Web.Mvc")
             .InNamespace("SharpArchTemplate.Web.Mvc.Controllers.Queries", true)
             .WithService.DefaultInterfaces());
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For<IMainWindow, IInvokable>().ImplementedBy<MainWindow>().LifeStyle.Singleton);
     container.Register(Component.For<ISystemNotification>().ImplementedBy<SystemNotification>().LifeStyle.Singleton);
     container.Register(Component.For<IGameDetailView>().ImplementedBy<GameDetailControl>().LifeStyle.Transient);
     container.Register (Component.For<IActiveSessionView> ().ImplementedBy<ActiveSessionControl> ().LifeStyle.Transient);
 }
        /// <summary>
        /// Performs the installation in the <see cref="T:Castle.Windsor.IWindsorContainer" />.
        /// </summary>
        /// <param name="container">The container.</param>
        /// <param name="store">The configuration store.</param>
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.AddFacility<LoggingFacility>(f => f.UseLog4Net());
            container.Register(
                Component.For<IRepository>()
                    .ImplementedBy<GenericRepository>()
                    .DependsOn(
                        Dependency.OnValue("connectionString", ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString),
                        Dependency.OnAppSettingsValue("databaseName", "DbName")),

                Component.For<IFoodProcessor>()
                    .ImplementedBy<FoodProcessor>(),

                Component.For<IBoardProcessor>()
                    .ImplementedBy<BoardProcessor>()
                    .DynamicParameters((DynamicParametersDelegate)GetBoardTemplates),

                Component.For<BoardTemplate>()
                    .ImplementedBy<DailyMenuBoardTemplate>()
                    .Named("DailyMenuBoardTemplate"),

                Component.For<BoardTemplate>()
                    .ImplementedBy<SalatsBoardTemplate>()
                    .Named("SalatsBoardTemplate"));
        }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Component.For<IConfigureWiringForTests, IResetTestDatabases>()
             .Instance(new DocumentDbTestConfigurer(container))
         );
 }
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(Component
                .For<IDatabaseContext>()
                .ImplementedBy<DatabaseContext>()
                .DependsOn(Dependency.OnValue("nameOrConnectionString", "DefaultConnection"))
                .LifeStyle.Transient
                );

            container.Register(Component
                .For<IUserStore>()
                .ImplementedBy<UserStore>()
                .LifeStyle.Transient);

            container.Register(Component
                .For<IPostStore>()
                .ImplementedBy<PostStore>()
                .LifeStyle.Transient
                );

            container.Register(Component
                .For<IUnitOfWork>()
                .ImplementedBy<UnitOfWork>()
                .LifeStyle.Transient
                );
        }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
        Component.For(typeof (ICustomWindowManager), typeof (IWindowManager)).ImplementedBy<CustomWindowManager>().LifeStyle.Is(LifestyleType.Singleton),
        Component.For<IEventAggregator>().ImplementedBy<EventAggregator>().LifeStyle.Is(LifestyleType.Singleton)
        );
 }
Example #11
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Classes.FromThisAssembly().BasedOn<IInitialiser>().WithService.FromInterface(),
         Component.For<IList<IInitialiser>>().UsingFactoryMethod<List<IInitialiser>>(
             c => new List<IInitialiser>(c.ResolveAll<IInitialiser>())));
 }
Example #12
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Classes
             .FromAssemblyInThisApplication()
             .BasedOn(typeof (ICommandHandler<>))
             .LifestyleTransient()
             .WithServiceBase(),
         Classes
             .FromAssemblyInThisApplication()
             .BasedOn(typeof (IEventHandler<>))
             .LifestyleTransient()
             .WithServiceBase(),
         Classes
             .FromAssemblyInThisApplication()
             .BasedOn(typeof (IQueryPerformer<,>))
             .LifestyleTransient()
             .WithServiceBase(),
         Component.For<ICommandBus>().ImplementedBy<CommandBus>(),
         Component.For<IEventBus>().ImplementedBy<EventBus>(),
         Component.For<IQueryBus>().ImplementedBy<QueryBus>(),
         Component.For<IAssistant>().ImplementedBy<Assistant>(),
         Component.For<IDateTimeGetter>().ImplementedBy<DateTimeGetter>()
         );
 }
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(Classes.FromThisAssembly()
                                .BasedOn<IController>()
                                .LifestyleTransient());

            container.Register(Component
                                .For<IControllerFactory>()
                                .UsingFactoryMethod(_ => new WindsorControllerFactory(container))
                                .LifeStyle.Singleton);

            container.Register(Component.For<IRdfTranslator>()
                                .UsingFactoryMethod(_ => new RdfTranslator(container.Resolve<IMongoDataContextProvider>()))
                                .LifeStyle.PerWebRequest);

            container.Register(Component.For<IMongoDataContextProvider>()
                                .UsingFactoryMethod(_ => new MongoDataContextProvider())
                                .LifeStyle.PerWebRequest);

            //container.Register(Component.For<IFormsAuthenticationService>()
            //                    .UsingFactoryMethod(_ => new FormsAuthenticationService())
            //                    .LifeStyle.PerWebRequest);

            //container.Register(Component.For<IMembershipService>()
            //                    .UsingFactoryMethod(_ => new AccountMembershipService())
            //                    .LifeStyle.PerWebRequest);
        }
Example #14
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(
                AllTypes.FromThisAssembly()
                    .BasedOn<IHttpController>().WithServiceSelf().LifestyleTransient(),

                //AllTypes.FromThisAssembly().BasedOn<Hub>().WithServiceSelf(),

                Component.For<DataPoints>(),

                Component.For<IHttpControllerSelector>().ImplementedBy<DefaultHttpControllerSelector>(),
                Component.For<IHttpControllerActivator>().ImplementedBy<DefaultHttpControllerActivator>().LifeStyle.Transient,
                Component.For<IHttpActionSelector>().ImplementedBy<ApiControllerActionSelector>().LifeStyle.Transient,
                Component.For<IActionValueBinder>().ImplementedBy<DefaultActionValueBinder>().LifeStyle.Transient,
                Component.For<IHttpActionInvoker>().ImplementedBy<ApiControllerActionInvoker>().LifeStyle.Transient,

                // http configuration needs to be registered with the container otherwise we can't
                // create controllers
                Component.For<HttpConfiguration>().Instance(httpConfiguration),

                Component.For<IStatrApi>().ImplementedBy<StatrApi>(),
                Component.For<IDataPointSubscriber>().ImplementedBy<DataPointSubscriber>()
                    .DependsOn(new { server = "localhost", port = 17892 }).OnCreate(d => d.Start()),

                Classes.FromThisAssembly().BasedOn<Controller>().LifestyleTransient());

            httpConfiguration.DependencyResolver = new WindsorWebApiDependencyResolver(container);
        }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     var config = container.Resolve<IDatabaseInitializerConfig>();
     switch (config.Initializer)
     {
         case Configs.InitializerTypes.DropCreateDatabaseAlways:
             container.Register(Component.For<IDatabaseInitializer<DomainContext<Domain>>>()
                 .ImplementedBy<DropCreateDatabaseAlways<DomainContext<Domain>>>().LifestyleSingleton());
             break;
         case Configs.InitializerTypes.DropCreateDatabaseIfModelChanges:
             container.Register(Component.For<IDatabaseInitializer<DomainContext<Domain>>>()
                 .ImplementedBy<DropCreateDatabaseIfModelChanges<DomainContext<Domain>>>().LifestyleSingleton());
             break;
         case Configs.InitializerTypes.CreateDatabaseIfNotExists:
             container.Register(Component.For<IDatabaseInitializer<DomainContext<Domain>>>()
                 .ImplementedBy<CreateDatabaseIfNotExists<DomainContext<Domain>>>().LifestyleSingleton());
             break;
         case Configs.InitializerTypes.NullDatabaseInitializer:
             container.Register(Component.For<IDatabaseInitializer<DomainContext<Domain>>>()
                 .ImplementedBy<NullDatabaseInitializer<DomainContext<Domain>>>().LifestyleSingleton());
             break;
         default:
             throw new NotImplementedException("Unknown Enumeration Value");
     }
 }
Example #16
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     // IPreferenceSet - Singleton
      container.Register(
     Component.For<Core.IPreferenceSet>()
        .ImplementedBy<PreferenceSet>());
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         //Component.For<ISessionFactory>().LifeStyle.Singleton.Instance(PersistenceManager.Factory),
         Component.For<ISession>().LifeStyle.PerWebRequest.UsingFactoryMethod(x => x.Resolve<ISessionFactory>().OpenSession())
         );
 }
Example #18
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(AllTypes.FromAssemblyNamed("TACO.Model")
                         .Where(Component.IsInNamespace("TACO.Model.Tasks.Concrete"))
                         .WithService.AllInterfaces()
                         .Configure(c => c.LifeStyle.Transient));
 }
Example #19
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(Component.For<ILogger>().ImplementedBy<ConsoleLogger>());

            container.Register(Component.For<ServiceHost>());

            container.Register(Component.For<IBus>().UsingFactory((IBusBuilder builder) => builder.Build()).LifeStyle.Singleton);

            container.Register(Component.For<IBusBuilder>().ImplementedBy<NybusBusBuilder>().OnCreate(ConfigureSubscriptions).LifeStyle.Singleton);

            container.Register(Component.For<INybusOptions>().ImplementedBy<NybusOptions>());

            container.Register(
                Component.For<IContainer>()
                    .ImplementedBy<WindsorBusContainer>()
                    .DependsOn(Dependency.OnValue<IKernel>(container.Kernel))
                    .LifeStyle.Singleton);

            container.Register(
                Component.For<IBusEngine>()
                    .ImplementedBy<MassTransitBusEngine>()
                    .LifeStyle.Singleton);

            container.Register(
                Component.For<MassTransitConnectionDescriptor>()
                    .UsingFactoryMethod(() => MassTransitConnectionDescriptor.FromConfiguration("ServiceBus")));


            container.Register(Component.For<MassTransitOptions>().OnCreate(ConfigureMassTransitOptions));
        }
Example #20
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.AddFacility<SqlServerPersistenceFacility>();
            container.AddFacility<DomainServicesFacility>();
            container.AddFacility<ApplicationServicesFacility>();

            container.Register(
                Classes.FromThisAssembly()
                    .BasedOn(typeof (IBootstrapper))
                    .WithServiceBase()
                    .LifestyleSingleton());

            // for bootstrappers
            container.Register(
                Component.For<WindsorControllerFactory>().ImplementedBy<WindsorControllerFactory>().LifestyleSingleton(),
                Component.For<WindsorValidatorFactory>().ImplementedBy<WindsorValidatorFactory>().LifestyleSingleton());

            // register all Fluent Validators
            container.Register(
                Classes.FromThisAssembly()
                .BasedOn(typeof(IValidator<>))
                .WithServiceBase()
                .LifestyleTransient());

            // register all controllers
            container.Register(Classes.FromThisAssembly()
                            .BasedOn<IController>()
                            .LifestyleTransient());
        }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     //register hubs as transient.  Our SignalR resolver will work around poor support for disposal in SignalR
     container.Register(
         Classes.FromThisAssembly().BasedOn(typeof(Hub<>)).WithServiceSelf().WithServiceAllInterfaces().LifestyleTransient()
         );
 }
 /// <summary>
 /// Performs the installation in the <see cref="T:Castle.Windsor.IWindsorContainer"/>.
 /// </summary>
 /// <param name="container">The container.</param><param name="store">The configuration store.</param>
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Classes.FromThisAssembly()
                              .InSameNamespaceAs<ValuesApiController>()
                              .LifestylePerWebRequest()
                              .Configure(x => x.Named(x.Implementation.FullName)));
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         // Most components
         Classes.FromThisAssembly().Pick().WithServiceFirstInterface().LifestyleTransient()
     );
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     //Application Services
     container.Register(
         //Singletons
         Component.For<IFormAuthenticationStoreService>().ImplementedBy<FormAuthenticationStoreService>().
             LifeStyle.Singleton,
         Component.For<ICryptoEngine>().Instance(new RijndaelEngine("S3CR3t0.3spC14L")).LifeStyle.Singleton,
         Component.For<IMembershipMailer>().ImplementedBy<MembershipMailer>().LifeStyle.Transient,
         Component.For<INotificationService>().ImplementedBy<NotificationService>().LifeStyle.Transient,
         Component.For<ISecurityService>().ImplementedBy<SecurityService>().LifeStyle.Singleton,
         //Providers
         Component.For<ICacheProvider>().ImplementedBy<InMemoryCacheProvider>().LifeStyle.Singleton,
         Component.For<IMappingEngine>().UsingFactoryMethod(() => Mapper.Engine).LifeStyle.Singleton,
         //Menu Provider
         //Queries
         AllTypes.FromThisAssembly().BasedOn<IQuery>()
             .WithService.DefaultInterface().Configure(x => x.LifeStyle.Transient),
         Component.For<IQueryFactory>().AsFactory(),
         //Report
         AllTypes.FromThisAssembly().BasedOn<IReport>()
             .WithService.DefaultInterface().Configure(x => x.LifeStyle.Transient),
         Component.For<IReportFactory>().AsFactory(),
         Component.For<IApplicationInstaller>().ImplementedBy<ApplicationInstaller>().LifeStyle.Singleton,
         //Transients
         Component.For<IMembershipService>().ImplementedBy<MembershipService>().LifeStyle.Transient
         );
 }
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var windsorContainer = container;
            
            //NHibernate Configuration
            windsorContainer.Register(
                Component.For<NHibernate.Cfg.Configuration>().UsingFactoryMethod(
                    _ => NHibernateSession.Configure(null, windsorContainer.Resolve<ZephyrConfiguration>())).LifestyleSingleton());
            
            //Nhibernate session factory
            windsorContainer.Register(
                Component.For<ISessionFactory>().UsingFactoryMethod(
                    k => k.Resolve<NHibernate.Cfg.Configuration>().BuildSessionFactory()).LifestyleSingleton());            

            if (ZephyrContext.IsWebApplication)
            {
                windsorContainer.Register(
                Component.For<ISession>().UsingFactoryMethod(k => k.Resolve<ISessionFactory>().OpenSession())
                    .LifestylePerWebRequest());                
            }
            else
            {
                windsorContainer.Register(
                Component.For<ISession>().UsingFactoryMethod(k => k.Resolve<ISessionFactory>().OpenSession())
                    .LifestyleTransient());
            }

            


            windsorContainer.Register(
                Component.For<IUnitOfWorkFactory>().ImplementedBy<NhUnitOfWorkFactory>().LifestyleTransient());
        }
Example #26
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For<TimeTrackerContext>());
     container.Register(Component.For<IService<Project>>().ImplementedBy<ProjectService>().LifeStyle.Transient);
     container.Register(Component.For<IService<Booking>>().ImplementedBy<BookingService>().LifeStyle.Transient);
     container.Register(Component.For<IService<User>>().ImplementedBy<UserService>().LifeStyle.Transient);
 }
        /// <summary>
        /// Processes a parameter map element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessParameterMapElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = null;

            if (element.Attributes.ContainsKey(ConfigConstants.ATTRIBUTE_CLASS))
            {
                config = new MutableConfiguration(
                        element.Name,
                        ApplyNamespace(element.Attributes[ConfigConstants.ATTRIBUTE_ID]),
                        element.Attributes[ConfigConstants.ATTRIBUTE_CLASS]);
            }
            else
            {
                config = new MutableConfiguration(
                        element.Name,
                        ApplyNamespace(element.Attributes[ConfigConstants.ATTRIBUTE_ID]));
            }
            config.CreateAttributes(element.Attributes);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);

            AddAttribute(config, ConfigConstants.ATTRIBUTE_EXTENDS, true);

            configurationStore.AddParameterMapConfiguration(config);
            element.Configuration = config;
        }
Example #28
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     if (ViewModelBase.IsInDesignModeStatic)
     {
         // SimpleIoc.Default.Register<IDataService, Design.DesignDataService>();
         container.Register(Component.For<IDataProvider>().ImplementedBy<DesignDataProvider>());
     }
     else
     {
         // SimpleIoc.Default.Register<IDataService, DataService>();
         container.Register(Component.For<IDataProvider>().ImplementedBy<DataProvider>());
     }
     //container.Register(Component.For<Window1>());
     //container.Register(Component.For<Window>().ImplementedBy<Window1>().LifeStyle.Transient);
     container.Register(Component.For<IWindow>().ImplementedBy<Window1>());
     container.Register(Component.For<IDepp>().ImplementedBy<OlderDepp>());
     //container.Register(Component.For<MainViewModel>()
       //  .ServiceOverrides(new { handler = "handler" }));
     container.Register(Component.For<MainViewModel>());
     //container.Register(Component.For<MainWindowAdapter>());
     //container.Register(Component.For<IWindow>().ImplementedBy<SubWindow>());
     //container.Register(AllTypes.FromThisAssembly().BasedOn<ViewModelBase>());
     //container.Register(AllTypes.FromThisAssembly().Pick()
     //    .If(Component.IsInSameNamespaceAs<FileIOService>()));
     //container.Register(AllTypes.FromThisAssembly().Pick()
     //                    .If(Component.IsInSameNamespaceAs<FormsAuthenticationService>())
     //                    .LifestyleTransient()
     //                    .WithService.DefaultInterfaces());
 }
Example #29
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Component.For(typeof(IFigureRenderer<PolygonFigure>))
         .ImplementedBy(typeof(PolygonRenderer))
         .LifestyleTransient());
 }
Example #30
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Classes.FromThisAssembly()
         .InNamespace("StatIt.Engine.Distimo.Services")
             .WithService.DefaultInterfaces()
             .LifestyleTransient());
 }
Example #31
0
 public TPaasProxy(IWebRequest webRequest, IConfigurationStore configurationStore, ILoggerFactory logger)
     : base(webRequest, configurationStore, logger)
 {
 }
Example #32
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container = container.Register(Classes.FromThisAssembly().BasedOn <IAction>().WithServiceSelf());
 }
Example #33
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Classes.FromThisAssembly().BasedOn <IController>().LifestyleTransient());
     container.Register(Component.For <Platform.Client.Common.Context.IContextProvider>().ImplementedBy <Platform.Client.Common.Context.HttpContextProvider>());
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For <ObjectInfoViewModel>().ImplementedBy <ObjectInfoViewModel>());
 }
Example #35
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Components().ToArray());
 }
Example #36
0
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var bus = new NotificationBus(container.Resolve <IServiceBus>());

            container.Register(Component.For <INotificationBus>().Instance(bus).LifeStyle.Singleton);
        }
Example #37
0
 public override void ProcessResource(IResource resource, IConfigurationStore store)
 {
 }
Example #38
0
 public void InstallAssembly(IWindsorContainer container, IConfigurationStore store)
 {
     container.RegisterThisAssembly();
 }
 /// <summary>
 /// Processes the SQL map element.
 /// </summary>
 /// <param name="element">The element.</param>
 /// <param name="configurationStore">The configuration store.</param>
 private void ProcessSqlMapElement(Tag element, IConfigurationStore configurationStore)
 {
     nameSpace = element.Attributes[ConfigConstants.ATTRIBUTE_NAMESPACE];
 }
Example #40
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 public CompactionCellController(IConfigurationStore configStore, IFileImportProxy fileImportProxy, ICompactionSettingsManager settingsManager)
     : base(configStore, fileImportProxy, settingsManager)
 {
 }
Example #41
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Classes.FromThisAssembly().BasedOn <MyModuleConfig>());
 }
Example #42
0
 public void DeclareDefaultServiceImplementations(IWindsorContainer container, IConfigurationStore store)
 {
     // None.
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For <ISetLifestyle>().ImplementedBy <WebLifestyle>());
     container.Register(Classes.FromThisAssembly().BasedOn <IController>().If(c => c.Name.EndsWith("Controller")).LifestylePerWebRequest());
     ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory(container));
 }
Example #44
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     this.InstallControllers(container);
     this.InstallInfrastructure(container);
 }
Example #45
0
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        var config = new NLog.Config.LoggingConfiguration();

        container.AddFacility <LoggingFacility>(l => l.LogUsing(new OwnNLogFactory(GetYourConnectionStringMethod(NLogConnectionString))));
    }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
 }
Example #47
0
 public CachedConfigurationStore(IConfigurationStore remoteConfigurationStore, ISensitiveDataProvider sensitiveDataProvider)
 {
     _remoteConfigurationStore = new SecureConfigurationStore(remoteConfigurationStore, sensitiveDataProvider);
 }
Example #48
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For <ILogger>().ImplementedBy <ConsoleLogger>());
     container.Register(Component.For <IRunner>().ImplementedBy <Runner>());
 }
Example #49
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.AddFacility <LoggingFacility>(f => f
                                             .LogUsing(LoggerImplementation.Log4net)
                                             .WithAppConfig());
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Classes.FromThisAssembly().BasedOn(typeof(ICommandHandler <>)).WithServiceBase().LifestyleTransient(),
         Classes.FromThisAssembly().BasedOn(typeof(ICommandHandler <,>)).WithServiceBase().LifestyleTransient());
 }
Example #51
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     GlobalConfiguration.Configuration.MessageHandlers.Add(new DeferredResolutionHmacAuthenticationHandler());
 }
Example #52
0
 public CachedConfigurationStore()
 {
     _remoteConfigurationStore = new SecureConfigurationStore(new ConsulConfigurationStore(), null);
 }
Example #53
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.RegisterHttpControllers(typeof(AnnouncementsController).Assembly);
 }
Example #54
0
 /// <summary>
 /// Performs the installation in the <see cref="T:Castle.Windsor.IWindsorContainer"/>.
 /// </summary>
 /// <param name="container">The container.</param><param name="store">The configuration store.</param>
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Classes.FromAssembly(typeof(PutBalanceRequestValidator).Assembly)
                        .BasedOn(typeof(AbstractValidator <>))
                        .WithServiceFirstInterface().LifestylePerWebRequest());
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For <ITime>().ImplementedBy <Time>(),
                        Component.For <IFileSystem>().ImplementedBy <LocalFileSystem>());
 }
 public ConfigurationStoreExceptionInterceptor(IConfigurationStore configurationStore)
 {
     this.configurationStore = configurationStore;
 }
Example #57
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Component.For <IDontExist>().ImplementedBy <DontExistImplementation>()
         );
 }
Example #58
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(
         Component.For <IHttpControllerFactory>().Instance(
             new WindsorHttpControllerFactory(container)));
 }
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For <IHandleMessages <TrashInspectionReceived> >().ImplementedBy <TrashInspectionReceivedHandler>().LifestyleTransient());
     container.Register(Component.For <IHandleMessages <TrashInspectionDeleted> >().ImplementedBy <TrashInspectionDeleteHandler>().LifestyleTransient());
     container.Register(Component.For <IHandleMessages <TrashInspectionCaseCreated> >().ImplementedBy <TrashInspectionCaseCreatedHandler>().LifestyleTransient());
 }
Example #60
0
 public void Install(IWindsorContainer container, IConfigurationStore store)
 {
     container.Register(Component.For(typeof(IReadOnlyRepository <>)).ImplementedBy(typeof(SqlDatabaseReadOnlyRepository <>)));
 }