예제 #1
0
        static void Main(string[] args)
        {
            // Create a new container
            var container = new SimpleInjector.Container();

            // Configure the container (Register)
            container.Register <LogConfiguration>();
            container.Register <IAccount, AccountController>();

            container.Collection.Register <ILogger>(typeof(ConsoleLogger), typeof(CompositeLogger));
            container.Collection.Append <ILogger, FileLoger>();

            var assemblies = new[] { typeof(ICommand <>).Assembly };

            //container.Register(typeof(ICommand<>), assemblies);
            container.Collection.Register(assemblies);

            container.Register <IHandler <AHandler>, AHandler>();
            container.Register <IHandler <BHandler>, BHandler>();
            container.RegisterInitializer <IHandler>(hdl => hdl.ExecuteAsynchronously = true);

            container.Register <Transient>(Lifestyle.Transient);
            //container.Register<Scoped>(Lifestyle.Scoped);
            container.Register <Singleton1>(Lifestyle.Singleton);
            container.RegisterInstance(new Singleton2());
            container.RegisterSingleton <Singleton3>();

            // Solve: Cycling dependency
            container.RegisterInstance <IServiceProvider>(container);
            container.Register <ServiceFactory>();
            container.Register <AService>();
            container.Register <BService>();

            // Verify the container (optional)
            container.Verify();
            Console.WriteLine("Verified ====>");

            // Retrieve instances from the container (Resolve)
            DemoRegisterInitializer(container);

            DemoChangeValue <Transient>(container);
            //DemoChangeValue<Scoped>(container);
            DemoChangeValue <Singleton1>(container);
            DemoChangeValue <Singleton2>(container);
            DemoChangeValue <Singleton3>(container);

            var depenOnB = container.GetInstance <AService>();
            var depenOnA = container.GetInstance <BService>();
        }
        /// <summary>
        /// DIコンテナへ生成インスタンスの登録を行います
        /// </summary>
        /// <param name="container"></param>
        public void SetDiContainer(SimpleInjector.Container container)
        {
            this.mContainer = container;

            container.RegisterInstance <IApplicationContext> (this);
            container.Register <ICategoryRepository, CategoryRepository> ();
            container.Register <IContentRepository, ContentRepository> ();
            container.Register <IEventLogRepository, EventLogRepository> ();
            container.Register <IFileMappingInfoRepository, FileMappingInfoRepository> ();
            container.Register <ILabelRepository, LabelRepository> ();
            container.Register <IWorkspaceRepository, WorkspaceRepository> ();
            container.Register <IAppAppMetaInfoRepository, AppAppMetaInfoRepository> ();
            container.Register <IThumbnailAppMetaInfoRepository, ThumbnailAppMetaInfoRepository> ();
            container.Register <IThumbnailRepository, ThumbnailRepository> ();
            container.Register <ApiResponseBuilder> ();
            container.Register <IAppDbContext, AppDbContext> (Lifestyle.Scoped);
            container.Register <IThumbnailDbContext, ThumbnailDbContext> (Lifestyle.Scoped);
            container.Register <IThumbnailBuilder, ThumbnailBuilder> ();
            container.Register <IFileUpdateRunner, FileUpdateRunner> ();

            // サービス登録
            container.Register <IVirtualFileSystemService, VirtualFileSystemServiceImpl> ();

            // メッセージング機能
            container.Register <IMessagingScopeContext, MessagingScopeContext> (Lifestyle.Scoped);
            var messagingManager = new MessagingManager(container);

            container.RegisterInstance <MessagingManager> (messagingManager);
            container.RegisterInstance <IMessagingManager> (messagingManager);

            // 拡張機能
            var extentionManager = new ExtentionManager(container);

            //extentionManager.AddPlugin (typeof (InitializeBuildExtention)); // 開発中は常に拡張機能を読み込む
            //extentionManager.AddPlugin (typeof (WebScribeExtention)); // 開発中は常に拡張機能を読み込む
            container.RegisterInstance <ExtentionManager> (extentionManager);
            extentionManager.InitializePlugin(ExtentionDirectoryPath);
            extentionManager.CompletePlugin();

            // VFS機能
            var virtualFileUpdateWatchService = new VirtualFileUpdateWatchService(container);

            container.RegisterInstance <VirtualFileUpdateWatchService> (virtualFileUpdateWatchService);
        }
예제 #3
0
        // Configure your AppHost with the necessary configuration and dependencies your App needs
        public override void Configure(Funq.Container container)
        {
            base.SetConfig(new HostConfig
            {
                DebugMode          = AppSettings.Get(nameof(HostConfig.DebugMode), false),
                HandlerFactoryPath = "api"
            });

            // plugins
            Plugins.Add(new TemplatePagesFeature());
            Plugins.Add(new ValidationFeature());

            SimpleContainer = new Container();
            //SimpleContainer.Options.DefaultScopedLifestyle = ScopedLifestyle.Flowing;

            container.Adapter = new SimpleInjectorIocAdapter(SimpleContainer);

            InitializeCache();

            InitializeDbConnectionFactory();

            InitializeMessaging();
            SimpleContainer.Register(() => Container.Adapter.Resolve <IMessageService>().MessageFactory);
            SimpleContainer.Register <IMessageProducer>(() => Container.Adapter.Resolve <IMessageFactory>().CreateMessageProducer(), Lifestyle.Transient);
            SimpleContainer.Register <IMessageQueueClient>(() => Container.Adapter.Resolve <IMessageFactory>().CreateMessageQueueClient(), Lifestyle.Transient);


            InitializeIntegrations();

            // repositories
            SimpleContainer.Register <ILinkRepository, LinkRepository>();
            SimpleContainer.Register <ITagRepository, TagRepository>();

            // validators
            SimpleContainer.Register <ITagValidator, TagValidator>();
            SimpleContainer.Collection.Register(typeof(IValidator <>), this.ServiceAssemblies);
            SimpleContainer.Collection.Register(typeof(ICreateLinkScreenshotHandler), this.ServiceAssemblies);

            //SimpleContainer.RegisterDecorator(...); // https://cuttingedge.it/blogs/steven/pivot/entry.php?id=93

            // events
            SimpleContainer.RegisterInstance <IEventBus>(new DomainEventBus(SimpleContainer));
            SimpleContainer.Collection.Register(typeof(IEventHandler <>), this.ServiceAssemblies);

            // Done container registration!
            SimpleContainer.Verify(VerificationOption.VerifyOnly);

            OnConfigEnding();

            // Messaging Service
            var mqHost = Container.Adapter.Resolve <IMessageService>();

            mqHost.RegisterHandler <CreateLinkScreenshotRequest>(base.ExecuteMessage);

            mqHost.Start();
        }
        public static void RegisterMvcIntegratedFilterProvider(this Container container)
        {
            if (container == null)
            {
                throw new ArgumentNullException(nameof(container));
            }

            RequiresFilterProviderNotRegistered(container);

            var singletonFilterProvider = new SimpleInjectorFilterAttributeFilterProvider(container);

            container.RegisterInstance <IFilterProvider>(singletonFilterProvider);

            var providers = FilterProviders.Providers.OfType <FilterAttributeFilterProvider>().ToList();

            providers.ForEach(provider => FilterProviders.Providers.Remove(provider));

            FilterProviders.Providers.Add(singletonFilterProvider);
        }
예제 #5
0
        public static SimpleInjector.Container GetInstance()
        {
            if (_container == null)
            {
                _container = new SimpleInjector.Container();

                _container.RegisterInstance(new DataBaseService());

                _container.Options.AllowOverridingRegistrations     = true;
                _container.Options.ResolveUnregisteredConcreteTypes = true;

                _container.Register <IPartnerRepository, PartnerRepository>(Lifestyle.Singleton);
                _container.Register <IPartnerService, PartnerService>(Lifestyle.Singleton);

                _container.Register <ReportService>(Lifestyle.Singleton);

                _container.Verify();
            }

            return(_container);
        }
예제 #6
0
        public static void Register(HttpConfiguration config)
        {
            var container = new SimpleInjector.Container();

            container.Options.DefaultScopedLifestyle = new SimpleInjector.Lifestyles.AsyncScopedLifestyle();


            container.Register <IAccountService, AccountService>(Lifestyle.Transient);
            container.RegisterInstance <ILogger>(LogManager.GetCurrentClassLogger());
            container.RegisterWebApiControllers(config);
            container.Verify();

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);

            config.Filters.Add(new ExceptionFilter());

            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );
        }
예제 #7
0
파일: Program.cs 프로젝트: lanicon/EVESharp
        static void Main(string[] argv)
        {
            Channel   logChannel     = null;
            Logger    log            = null;
            Thread    logFlushing    = null;
            Semaphore cacheSemaphore = new Semaphore(0, 1);
            Semaphore itemSemaphore  = new Semaphore(0, 1);

            try
            {
                // create the dependency injector container
                Container dependencies = new Container();

                // register basic dependencies first
                dependencies.Register <Logger>(Lifestyle.Singleton);
                dependencies.Register <DatabaseConnection>(Lifestyle.Singleton);
                dependencies.Register <ClientManager>(Lifestyle.Singleton);
                dependencies.Register <NodeContainer>(Lifestyle.Singleton);
                dependencies.Register <CacheStorage>(Lifestyle.Singleton);
                dependencies.Register <ItemManager>(Lifestyle.Singleton);
                dependencies.Register <MetaInventoryManager>(Lifestyle.Singleton);
                dependencies.Register <AttributeManager>(Lifestyle.Singleton);
                dependencies.Register <TypeManager>(Lifestyle.Singleton);
                dependencies.Register <CategoryManager>(Lifestyle.Singleton);
                dependencies.Register <GroupManager>(Lifestyle.Singleton);
                dependencies.Register <StationManager>(Lifestyle.Singleton);
                dependencies.Register <ItemFactory>(Lifestyle.Singleton);
                dependencies.Register <TimerManager>(Lifestyle.Singleton);
                dependencies.Register <SystemManager>(Lifestyle.Singleton);
                dependencies.Register <ServiceManager>(Lifestyle.Singleton);
                dependencies.Register <BoundServiceManager>(Lifestyle.Singleton);
                dependencies.Register <ClusterConnection>(Lifestyle.Singleton);
                dependencies.Register <CharacterManager>(Lifestyle.Singleton);
                dependencies.Register <NotificationManager>(Lifestyle.Singleton);
                dependencies.Register <MachoNet>(Lifestyle.Singleton);
                dependencies.Register <ExpressionManager>(Lifestyle.Singleton);
                dependencies.Register <WalletManager>(Lifestyle.Singleton);
                dependencies.Register <MailManager>(Lifestyle.Singleton);

                // register the database accessors dependencies
                dependencies.Register <AccountDB>(Lifestyle.Singleton);
                dependencies.Register <AgentDB>(Lifestyle.Singleton);
                dependencies.Register <BookmarkDB>(Lifestyle.Singleton);
                dependencies.Register <CertificatesDB>(Lifestyle.Singleton);
                dependencies.Register <CharacterDB>(Lifestyle.Singleton);
                dependencies.Register <ChatDB>(Lifestyle.Singleton);
                dependencies.Register <ConfigDB>(Lifestyle.Singleton);
                dependencies.Register <ContractDB>(Lifestyle.Singleton);
                dependencies.Register <CorporationDB>(Lifestyle.Singleton);
                dependencies.Register <GeneralDB>(Lifestyle.Singleton);
                dependencies.Register <ItemDB>(Lifestyle.Singleton);
                dependencies.Register <MarketDB>(Lifestyle.Singleton);
                dependencies.Register <MessagesDB>(Lifestyle.Singleton);
                dependencies.Register <SkillDB>(Lifestyle.Singleton);
                dependencies.Register <StandingDB>(Lifestyle.Singleton);
                dependencies.Register <StationDB>(Lifestyle.Singleton);
                dependencies.Register <LookupDB>(Lifestyle.Singleton);
                dependencies.Register <InsuranceDB>(Lifestyle.Singleton);
                dependencies.Register <SolarSystemDB>(Lifestyle.Singleton);
                dependencies.Register <DogmaDB>(Lifestyle.Singleton);
                dependencies.Register <RepairDB>(Lifestyle.Singleton);
                dependencies.Register <ReprocessingDB>(Lifestyle.Singleton);
                dependencies.Register <RAMDB>(Lifestyle.Singleton);
                dependencies.Register <FactoryDB>(Lifestyle.Singleton);
                dependencies.Register <WalletDB>(Lifestyle.Singleton);

                // register all the services
                dependencies.Register <account>(Lifestyle.Singleton);
                dependencies.Register <machoNet>(Lifestyle.Singleton);
                dependencies.Register <objectCaching>(Lifestyle.Singleton);
                dependencies.Register <alert>(Lifestyle.Singleton);
                dependencies.Register <authentication>(Lifestyle.Singleton);
                dependencies.Register <character>(Lifestyle.Singleton);
                dependencies.Register <userSvc>(Lifestyle.Singleton);
                dependencies.Register <charmgr>(Lifestyle.Singleton);
                dependencies.Register <config>(Lifestyle.Singleton);
                dependencies.Register <dogmaIM>(Lifestyle.Singleton);
                dependencies.Register <invbroker>(Lifestyle.Singleton);
                dependencies.Register <warRegistry>(Lifestyle.Singleton);
                dependencies.Register <station>(Lifestyle.Singleton);
                dependencies.Register <map>(Lifestyle.Singleton);
                dependencies.Register <skillMgr>(Lifestyle.Singleton);
                dependencies.Register <contractMgr>(Lifestyle.Singleton);
                dependencies.Register <corpStationMgr>(Lifestyle.Singleton);
                dependencies.Register <bookmark>(Lifestyle.Singleton);
                dependencies.Register <LSC>(Lifestyle.Singleton);
                dependencies.Register <onlineStatus>(Lifestyle.Singleton);
                dependencies.Register <billMgr>(Lifestyle.Singleton);
                dependencies.Register <facWarMgr>(Lifestyle.Singleton);
                dependencies.Register <corporationSvc>(Lifestyle.Singleton);
                dependencies.Register <clientStatsMgr>(Lifestyle.Singleton);
                dependencies.Register <voiceMgr>(Lifestyle.Singleton);
                dependencies.Register <standing2>(Lifestyle.Singleton);
                dependencies.Register <tutorialSvc>(Lifestyle.Singleton);
                dependencies.Register <agentMgr>(Lifestyle.Singleton);
                dependencies.Register <corpRegistry>(Lifestyle.Singleton);
                dependencies.Register <marketProxy>(Lifestyle.Singleton);
                dependencies.Register <stationSvc>(Lifestyle.Singleton);
                dependencies.Register <certificateMgr>(Lifestyle.Singleton);
                dependencies.Register <jumpCloneSvc>(Lifestyle.Singleton);
                dependencies.Register <LPSvc>(Lifestyle.Singleton);
                dependencies.Register <lookupSvc>(Lifestyle.Singleton);
                dependencies.Register <insuranceSvc>(Lifestyle.Singleton);
                dependencies.Register <slash>(Lifestyle.Singleton);
                dependencies.Register <ship>(Lifestyle.Singleton);
                dependencies.Register <corpmgr>(Lifestyle.Singleton);
                dependencies.Register <repairSvc>(Lifestyle.Singleton);
                dependencies.Register <reprocessingSvc>(Lifestyle.Singleton);
                dependencies.Register <ramProxy>(Lifestyle.Singleton);
                dependencies.Register <factory>(Lifestyle.Singleton);

                dependencies.RegisterInstance(General.LoadFromFile("configuration.conf", dependencies));
                // disable auto-verification on the container as it triggers creation of instances before they're needed
                dependencies.Options.EnableAutoVerification = false;

                General configuration = dependencies.GetInstance <General>();

                log = dependencies.GetInstance <Logger>();

                logChannel = log.CreateLogChannel("main");
                // add log streams
                log.AddLogStream(new ConsoleLogStream());

                if (configuration.LogLite.Enabled == true)
                {
                    log.AddLogStream(new LogLiteStream("Node", log, configuration.LogLite));
                }
                if (configuration.FileLog.Enabled == true)
                {
                    log.AddLogStream(new FileLogStream(configuration.FileLog));
                }

                // run a thread for log flushing
                logFlushing = new Thread(() =>
                {
                    try
                    {
                        while (true)
                        {
                            log.Flush();
                            Thread.Sleep(1);
                        }
                    }
                    catch
                    {
                        // ignored
                    }
                });
                logFlushing.Start();

                logChannel.Info("Initializing EVESharp Node");
                logChannel.Fatal("Initializing EVESharp Node");
                logChannel.Error("Initializing EVESharp Node");
                logChannel.Warning("Initializing EVESharp Node");
                logChannel.Debug("Initializing EVESharp Node");
                logChannel.Trace("Initializing EVESharp Node");

                // connect to the database
                dependencies.GetInstance <DatabaseConnection>();
                // sDatabase.Query("SET global max_allowed_packet=1073741824");

                // create the node container
                dependencies.GetInstance <NodeContainer>();

                logChannel.Info("Initializing timer manager");
                dependencies.GetInstance <TimerManager>().Start();
                logChannel.Debug("Done");

                // do some parallel initialization, cache priming and static item loading can be performed in parallel
                // this makes the changes quicker
                new Thread(() =>
                {
                    logChannel.Info("Initializing cache");
                    CacheStorage cacheStorage = dependencies.GetInstance <CacheStorage>();
                    // prime bulk data
                    cacheStorage.Load(
                        CacheStorage.LoginCacheTable,
                        CacheStorage.LoginCacheQueries,
                        CacheStorage.LoginCacheTypes
                        );
                    // prime character creation cache
                    cacheStorage.Load(
                        CacheStorage.CreateCharacterCacheTable,
                        CacheStorage.CreateCharacterCacheQueries,
                        CacheStorage.CreateCharacterCacheTypes
                        );
                    // prime character appearance cache
                    cacheStorage.Load(
                        CacheStorage.CharacterAppearanceCacheTable,
                        CacheStorage.CharacterAppearanceCacheQueries,
                        CacheStorage.CharacterAppearanceCacheTypes
                        );
                    logChannel.Info("Cache Initialized");
                    cacheSemaphore.Release(1);
                }).Start();

                new Thread(() =>
                {
                    logChannel.Info("Initializing item factory");
                    dependencies.GetInstance <ItemFactory>().Init();
                    logChannel.Debug("Item Factory Initialized");

                    itemSemaphore.Release(1);
                }).Start();

                // wait for both semaphores
                cacheSemaphore.WaitOne();
                itemSemaphore.WaitOne();

                logChannel.Info("Initializing solar system manager");
                dependencies.GetInstance <SystemManager>();
                logChannel.Debug("Done");

                dependencies.GetInstance <MachoNet>().ConnectToProxy();

                logChannel.Trace("Node startup done");

                while (true)
                {
                    Thread.Sleep(1);
                }
            }
            catch (Exception e)
            {
                if (log is null || logChannel is null)
                {
                    Console.WriteLine(e.ToString());
                }