public AutoMockedContainer(ServiceLocator locator)
        {
            _locator = locator;

            onMissingFactory = delegate(Type pluginType, ProfileManager profileManager)
            {
                //Modified to inject concrete classes that have virtual methods
                if (!pluginType.IsAbstract && pluginType.IsClass &&
                    !pluginType.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).Where(p => p.IsVirtual).Any())
                {
                    return null;
                }

                var factory = new InstanceFactory(new PluginFamily(pluginType));

                try
                {
                    object service = _locator.Service(pluginType);

                    var instance = new ObjectInstance(service);

                    profileManager.SetDefault(pluginType, instance);
                }
                catch (Exception)
                {
                    // ignore errors
                }

                return factory;
            };
        }
Exemple #2
0
        public static void Main(string[] args)
        {
            string name = "Foobar Mirror";
            ushort port = 3690;

            if (args.Length > 0)
                name = args[0];
            if (args.Length > 1)
                port = UInt16.Parse (args[1]);

            server = new Server (name);
            server.Port = port;
            server.Start ();

            ServiceLocator locator = new ServiceLocator ();
            locator.Found += OnServiceFound;
            locator.Removed += OnServiceRemoved;
            locator.Start ();

            Console.WriteLine ("Press enter to quit");
            Console.ReadLine ();

            foreach (Client client in clients) {
                client.Logout ();
            }

            locator.Stop ();
            server.Stop ();
        }
        public AutoMockedContainer(ServiceLocator locator)
        {
            _locator = locator;

            onMissingFactory = delegate(Type pluginType, ProfileManager profileManager)
            {
                if (!pluginType.IsAbstract && pluginType.IsClass)
                {
                    return null;
                }

                var factory = new InstanceFactory(new PluginFamily(pluginType));

                try
                {
                    object service = _locator.Service(pluginType);

                    var instance = new ObjectInstance(service);

                    profileManager.SetDefault(pluginType, instance);
                }
                catch (Exception)
                {
                    // ignore errors
                }

                return factory;
            };
        }
Exemple #4
0
        public static void Initialize()
        {
            ServerAddress = "localhost:11648";

            ObjectFactory.Configure(c =>
            {
                c.ForRequestedType<IFrameRateTimerFactory>().TheDefaultIsConcreteType<FrameRateTimerFactory>().CacheBy(StructureMap.Attributes.InstanceScope.Singleton);
                c.ForRequestedType<IEmulationRunner>().TheDefault.Is.OfConcreteType<EmulationRunner>();
                c.ForRequestedType<IEventAggregator>().TheDefaultIsConcreteType<EventAggregator>().CacheBy(StructureMap.Attributes.InstanceScope.Singleton);
            });

            _serviceLocator = new ServiceLocator();

            _serviceLocator.RegisterSingleton<IInputSourceAssembler, InputSourceAssembler>();
            _serviceLocator.RegisterSingleton<IEmulatorRegistry, EmulatorRegistry>();

            _loader = new ModuleLoader();
            _context = new ModuleContext()
                {
                    ServiceLocator = _serviceLocator,
                    InputSourceAssembler = _serviceLocator.GetInstance<IInputSourceAssembler>(),
                    EmulatorRegistry = _serviceLocator.GetInstance<IEmulatorRegistry>()
                };
            _loader.LoadModules(_context);        
        }
        public AutoMockedContainer(ServiceLocator locator)
        {
            nameContainer(this);

            _locator = locator;
            Model.Pipeline.Outer.AddFamilyPolicy(this);
        }
        public void Initialize(HttpConfiguration configuration, Pandora pandora)
        {
            var container = new Container();
            container.RegisterSingleton<Pandora>(() => pandora);
            Func<IPipelineTransport> transport = () => container.Resolve<IPipelineTransport>();
            Func<ISerializer> serializer = () => container.Resolve<ISerializer>();
            container.RegisterSingleton<IPublisher<ICommand>>(() => new PipelinePublisher<ICommand>(transport(), serializer()));

            var serviceLocator = new ServiceLocator(container);
            ControllerFactory = new ServiceLocatorFactory(serviceLocator);

            var cfg = new CronusSettings(container)
                  .UseCluster(cluster =>
                       cluster.UseAggregateRootAtomicAction(atomic =>
                       {
                           if (pandora.Get<bool>("enable_redis_atomic_action"))
                               atomic.UseRedis(redis => redis.SetLockEndPoints(pandora.Get("redis_endpoints").ParseIPEndPoints(";")));
                           else
                               atomic.WithInMemory();
                       }))
                  .UseContractsFromAssemblies(new[] { Assembly.GetAssembly(typeof(PushNotificationWasSent)) })
                  .UseRabbitMqTransport(x =>
                  {
                      x.Server = pandora.Get("rabbitmq_server");
                      x.Username = pandora.Get("rabbitmq_username");
                      x.Password = pandora.Get("rabbitmq_password");
                      x.VirtualHost = pandora.Get("rabbitmq_virtualhost");
                  });

            (cfg as ICronusSettings).Build();
        }
        public void Init(ServiceLocator sl, ref PluginSetting setting)
        {
            if (string.IsNullOrEmpty(setting["enable"]))
                setting.Enable = !HttpContext.Current.IsDebuggingEnabled;

            if (!setting.Enable) return;

            ErrorHandler eh = new ErrorHandler();
            eh.Start();
            sl.AddComponentInstance<IErrorHandler>(eh);

            List<string> emails = new List<string>(StringUtil.Split(setting["notifyEmails"], StringUtil.Comma, true, true));

            if (emails.Count == 0) return;

            ErrorHandler.NotifyError += (sender, e) =>
            {
                try
                {
                    Dictionary<string, object> param = new Dictionary<string, object>();
                    param["jc"] = JContext.Current;
                    param["exception"] = ExceptionUtil.WriteException(e.Exception);

                    Kiss.Notice.NoticeFactory.Create("Email").Send("未处理异常", param,
                        null,
                        emails.ToArray());
                }
                catch (Exception ex)
                {
                    LogManager.GetLogger<ExceptionHandlerInitializer>().Error(ExceptionUtil.WriteException(ex));
                }
            };
        }
Exemple #8
0
        public static void Main(string[] args)
        {
            if (args.Length == 0) {
                ServiceLocator locator = new ServiceLocator ();
                locator.Found += OnServiceFound;
                locator.Removed += OnServiceRemoved;
                locator.Start ();
            } else {
                string host = args[0];

                ushort port = 3689;
                if (args.Length > 1)
                    port = UInt16.Parse (args[1]);

                Client client = new Client (host, port);
                client.Login ();
                AddClient (client);
            }

            Console.WriteLine ("Press enter to quit");
            Console.ReadLine ();

            foreach (Client client in clients) {
                client.Logout ();
            }
        }
Exemple #9
0
 public void Configure()
 {
     _services = new ServiceLocator();
     _services.Container.Kernel.Resolver.AddSubResolver(new ArrayResolver(_services.Container.Kernel));
     _services.Container
         .Register(Component.For<IServiceLocator>().Instance(_services))
         .Register(Component.For<IMessageBus>().ImplementedBy<MessageBus>().LifeStyle.Singleton)
         .Register(Component.For<IFileSystemService>().ImplementedBy<FileSystemService>())
         .Register(Component.For<IProjectParser>().ImplementedBy<ProjectParser>())
         .Register(Component.For<ICreate<Project>>().ImplementedBy<ProjectFactory>())
         .Register(Component.For<IPrepare<Project>>().ImplementedBy<ProjectPreparer>())
         .Register(
         Component.For<IBlockingConsumerOf<ProjectChangeMessage>>().ImplementedBy<ProjectChangeConsumer>())
         .Register(Component.For<IConsumerOf<FileChangeMessage>>().ImplementedBy<FileChangeConsumer>())
         .Register(Component.For<ICache>().ImplementedBy<Cache>().LifeStyle.Singleton)
         .Register(Component.For<IWatchValidator>().ImplementedBy<WatchValidator>())
         .Register(Component.For<ILocateProjects>().ImplementedBy<CSharpLocator>())
         .Register(Component.For<ILocateProjects>().ImplementedBy<VisualBasicLocator>())
         .Register(Component.For<IInformationFeedbackPresenter>().ImplementedBy<InformationFeedbackPresenter>())
         .Register(Component.For<IRunFeedbackPresenter>().ImplementedBy<RunFeedbackPresenter>())
         .Register(Component.For<IDirectoryWatcher>().ImplementedBy<DirectoryWatcher>())
         .Register(Component.For<IConfiguration>().ImplementedBy<Config>())
         .Register(Component.For<ICrawlForProjectFiles>().ImplementedBy<ProjectFileCrawler>())
         .Register(Component.For<IReload<Project>>().ImplementedBy<ProjectReloader>())
         .Register(Component.For<IPrioritizeProjects>().ImplementedBy<ProjectPrioritizer>())
         .Register(Component.For<IBuildRunner>().ImplementedBy<MSBuildRunner>())
         .Register(Component.For<ITestRunner>().ImplementedBy<NUnitTestRunner>())
         .Register(Component.For<ITestRunner>().ImplementedBy<MSTestRunner>())
         .Register(Component.For<ITestRunner>().ImplementedBy<XUnitTestRunner>())
         .Register(Component.For<IGenerateBuildList>().ImplementedBy<BuildListGenerator>())
         .Register(Component.For<IMergeRunResults>().Forward<IRunResultCache>().ImplementedBy<RunResultCache>())
         .Register(Component.For<ApplicatonLauncher>());
 }
Exemple #10
0
        private void ConfigureContainer()
        {
            _container = new SimpleContainer();

            var appSettings = new AppSettings();

            var services = new ServiceLocator(_container);

            _container.Instance<AppSettings>(appSettings);
            _container.Singleton<IFileSystem, FileSystem>();
            _container.Singleton<IDirectorySystem, DirectorySystem>();
            _container.Instance<IServiceLocator>(services);
            _container.PerRequest<IAsyncSocket, AsyncSocket>();
            _container.PerRequest<IAuthenticationServer, AuthenticationServer>();
            _container.Singleton<IGameParser, NewGameParser>();
            _container.Singleton<IGameState, SimpleGameState>();
            _container.Singleton<IGameServer, SimpleGameServer>();
            _container.Singleton<IScriptLoader, ScriptLoader>();
            _container.Singleton<IScriptRunner, ScriptRunner>();
            _container.Singleton<IRoundtimeHandler, RoundtimeHandler>();
            _container.Singleton<WaitForTokenHandler>();
            _container.Singleton<WaitForReTokenHandler>();
            _container.Singleton<MatchWaitTokenHandler>();

            _container.PerRequest<ITagTransformer, ComponentTagTransformer>();
            _container.PerRequest<ITagTransformer, StreamWindowTagTransformer>();

            _container.PerRequest<IIfBlockExecuter, IfBlockExecuter>();
            _container.Singleton<IIfBlocksParser, IfBlocksParser>();

            _container.PerRequest<IScript, Script>();
            _container.Singleton<IScriptLog, ScriptLog>();

            _container.PerRequest<IVariableReplacer, VariableReplacer>();
            _container.Singleton<ICommandProcessor, CommandProcessor>();

            _container.Singleton<IGameStream, GameStream>();

            _container.Singleton<ISendQueue, SendQueue>();

            _container.Singleton<IConfigLoader, ConfigLoader>();
            _container.Singleton<IVariablesLoader, VariablesLoader>();
            _container.Singleton<IHighlightsLoader, HighlightsLoader>();
            _container.Singleton<IAppDirectoriesBuilder, AppDirectoriesBuilder>();
            _container.Singleton<IAppSettingsLoader, AppSettingsLoader>();
            _container.Singleton<IProfileLoader, ProfileLoader>();

            var now = DateTime.Now.ToString("s");
            var logFileName = string.Format("{0}-log.txt", now);
            var errorsFileName = string.Format("{0}-errors.txt", now);

            var logger = new SimpleFileLogger(logFileName, errorsFileName, services);

            var compositeLog = new CompositeLog(new ILog[]{ logger });

            _container.Instance<ILog>(compositeLog);

            SetupHighlights();
        }
 public void TestSetup()
 {
     this.ServicePocoClient = new TestNetworkServicePocoClient();
     this.ServiceLocator = new ServiceLocator();
     
     var manager = this.ServiceLocator.Locate<IServiceLocationOverrideManager>();
     manager.RegisterServiceInstance(typeof(INetworkServicePocoClientFactory), new TestNetworkServicePocoClientFactory(this.ServicePocoClient));
 }
	public void Init(ServiceLocator serloc)
	{
		Debug.Log("Setting up gear manager.");
		_serloc = serloc;
		_evtmgr = serloc.GetService("EventManager") as IEventService;
		Debug.Log("Calling event manager: ");
		_evtmgr.DoEventRelatedStuff();
	}
        /// <summary>
        /// Creates a new AutoMockedContainer using the supplied ServiceLocator
        /// </summary>
        /// <param name="locator"></param>
        public AutoMockedContainer(ServiceLocator locator)
        {
            nameContainer(this);

            Configure(x => x.Policies.OnMissingFamily(this));

            _locator = locator;
        }
	public void Init(ServiceLocator serloc)
	{
		Debug.Log("Setting up event manager.");
		_serloc = serloc;
		_gearmgr = _serloc.GetService("GearManager") as IGearService;
		Debug.Log("Calling gear service through IGearService: ");
		_gearmgr.DoGearRelatedStuff();
	}
        public void Init(ServiceLocator sl, ref PluginSetting setting)
        {
            if (!setting.Enable) return;

            UrlMappingModule module = new UrlMappingModule();
            module.Start();
            sl.AddComponentInstance(module);
        }
        /// <summary>
        /// Initializes static members of the <see cref="IoCConfiguration"/> class.
        /// </summary>
        static IoCConfiguration()
        {
            var serviceLocator = new ServiceLocator();

            DefaultServiceLocator = serviceLocator;
            DefaultDependencyResolver = serviceLocator.ResolveType<IDependencyResolver>();
            DefaultTypeFactory = serviceLocator.ResolveType<ITypeFactory>();
        }
        public void Configure(ILocateWriteLocation defaultConfigurationLocator)
        {
            _services = new ServiceLocator();
            _services.Container.Kernel.Resolver.AddSubResolver(new ArrayResolver(_services.Container.Kernel));
            _services.Container
                .Register(Component.For<IServiceLocator>().Instance(_services))
                .Register(Component.For<IMessageBus>().ImplementedBy<MessageBus>().LifeStyle.Singleton)
                .Register(Component.For<IFileSystemService>().ImplementedBy<FileSystemService>())
                .Register(Component.For<IProjectParser>().ImplementedBy<ProjectParser>())
                .Register(Component.For<ICreate<Project>>().ImplementedBy<ProjectFactory>())
                .Register(Component.For<IPrepare<Project>>().ImplementedBy<ProjectPreparer>())
                .Register(Component.For<IOverridingConsumer<ProjectChangeMessage>>().ImplementedBy<ProjectChangeConsumer>().LifeStyle.Singleton)
                .Register(Component.For<IConsumerOf<FileChangeMessage>>().ImplementedBy<FileChangeConsumer>().Named("MSBuild"))
				.Register(Component.For<IConsumerOf<FileChangeMessage>>().ImplementedBy<BinaryFileChangeConsumer>().Named("NoBuild"))
                .Register(Component.For<ICache>().ImplementedBy<Cache>().LifeStyle.Singleton)
                .Register(Component.For<IWatchValidator>().ImplementedBy<WatchValidator>())
                .Register(Component.For<ILocateProjects>().ImplementedBy<CSharpLocator>())
                .Register(Component.For<ILocateProjects>().ImplementedBy<VisualBasicLocator>())
                .Register(Component.For<IInformationFeedbackPresenter>().ImplementedBy<InformationFeedbackPresenter>())
                .Register(Component.For<IRunFeedbackPresenter>().ImplementedBy<RunFeedbackPresenter>())
                .Register(Component.For<IDirectoryWatcher>().ImplementedBy<DirectoryWatcher>().LifeStyle.Singleton)
                .Register(Component.For<IConfiguration>().ImplementedBy<Config>())
                .Register(Component.For<ICrawlForProjectFiles>().ImplementedBy<ProjectFileCrawler>())
                .Register(Component.For<IReload<Project>>().ImplementedBy<ProjectReloader>())
                .Register(Component.For<IPrioritizeProjects>().ImplementedBy<ProjectPrioritizer>())
                .Register(Component.For<IBuildRunner>().ImplementedBy<MSBuildRunner>())
                .Register(Component.For<ITestRunner>().ImplementedBy<NUnitTestRunner>())
                .Register(Component.For<ITestRunner>().ImplementedBy<MSTestRunner>())
                .Register(Component.For<ITestRunner>().ImplementedBy<XUnitTestRunner>())
                .Register(Component.For<ITestRunner>().ImplementedBy<MSpecTestRunner>())
                .Register(Component.For<ITestRunner>().ImplementedBy<AutoTestTestRunner>())
                .Register(Component.For<IExternalProcess>().ImplementedBy<HiddenExternalProcess>())
                .Register(Component.For<IMSpecCommandLineBuilder>().ImplementedBy<MSpecCommandLineBuilder>())
                .Register(Component.For<IGenerateBuildList>().ImplementedBy<BuildListGenerator>())
                .Register(Component.For<IMergeRunResults>().Forward<IRunResultCache>().ImplementedBy<RunResultCache>())
				.Register(Component.For<IRetrieveAssemblyIdentifiers>().ImplementedBy<AssemblyParser>())
				.Register(Component.For<IOverridingConsumer<AssemblyChangeMessage>>().ImplementedBy<AssemblyChangeConsumer>().LifeStyle.Singleton)
				.Register(Component.For<IDetermineIfAssemblyShouldBeTested>().ImplementedBy<TestRunValidator>())
				.Register(Component.For<IOptimizeBuildConfiguration>().ImplementedBy<BuildOptimizer>())
				.Register(Component.For<IPreProcessTestruns>().ImplementedBy<NullPreProcessor>())
                .Register(Component.For<IPreProcessBuildruns>().ImplementedBy<NullBuildPreProcessor>())
				.Register(Component.For<IHandleDelayedConfiguration>().ImplementedBy<DelayedConfigurer>())
				.Register(Component.For<IMarkProjectsForRebuild>().ImplementedBy<ProjectRebuildMarker>())
                .Register(Component.For<ILocateRemovedTests>().ImplementedBy<RemovedTestsLocator>())
                .Register(Component.For<ISolutionChangeConsumer>().ImplementedBy<SolutionChangeConsumer>())
                .Register(Component.For<ISolutionParser>().ImplementedBy<SolutionCrawler>())
                .Register(Component.For<IAssemblyReader>().ImplementedBy<AssemblyReader>())
                .Register(Component.For<IApplicatonLauncher>().ImplementedBy<ApplicatonLauncher>().LifeStyle.Singleton)
                .Register(Component.For<ICustomIgnoreProvider>().ImplementedBy<NullIgnoreProvider>())
                .Register(Component.For<IWriteDebugInfo>().ImplementedBy<DebugWriter>().LifeStyle.Singleton)
                .Register(Component.For<IWatchPathLocator>().ImplementedBy<WatchPathLocator>());

            if (defaultConfigurationLocator == null)
                defaultConfigurationLocator = new DefaultConfigurationLocator();
            _services.Container.Register(Component.For<ILocateWriteLocation>().Instance(defaultConfigurationLocator));
			
			initializeNotifiers();
        }
        public void Init(ServiceLocator sl, ref PluginSetting setting)
        {
            if (!setting.Enable) return;

            DynamicQueryPlugin plugin = new DynamicQueryPlugin();
            plugin.Start();

            sl.AddComponentInstance<DynamicQueryPlugin>(plugin);
        }
Exemple #19
0
    void Awake()
    {
        serviceLocator = new ServiceLocator();

        CreatePlayer();
        CreateBoundariesController();
        CreateEnemySpawner();
        CreatePointer();
    }
		public void Correctly_Constructs_Instance_With_Key()
		{
            InfrastructureDependencyRegistrar.RegisterInfrastructure();
			IServiceLocator serviceLocator = new ServiceLocator();

			var instance = serviceLocator.CreateInstance<IDatabaseActionExecutor>("Create");

			Assert.That(instance, Is.Not.Null);
		}
Exemple #21
0
 /// <summary>
 /// Builds this instance.
 /// </summary>
 /// <returns></returns>
 public IServiceLocator Build()
 {
     var locator = new ServiceLocator();
     locator
         .Register(DataAccessFactory.Create<ReportDao>())
         .Register<ParametersDao>((serviceLocator) =>
             DataAccessFactory.CreateWithSameContext<ParametersDao>(serviceLocator.Resolve<ReportDao>()));
     return locator;
 }
Exemple #22
0
        private static ServiceLocator CreateServiceLocator()
        {
            ServiceLocator serviceLocator = new ServiceLocator();
            serviceLocator.RegisterService<IMatrixService>(new MatrixService(serviceLocator));
            serviceLocator.RegisterService<IMatrixAlgorithmsService>(new MatrixAlgorithmsService());
            serviceLocator.RegisterService<IMathService>(new MathService());

            return serviceLocator;
        }
		public void Correctly_Constructs_Instance()
		{
            InfrastructureDependencyRegistrar.RegisterInfrastructure();
			IServiceLocator serviceLocator = new ServiceLocator();

			var instance = serviceLocator.CreateInstance<IResourceFileLocator>();

			Assert.That(instance, Is.Not.Null);
		}
		public void Enumerable()
		{
			var parts = typeof(ExportedClass).Append( typeof(AnotherExportedClass) ).AsApplicationParts();
			var container = new ContainerConfiguration().WithParts( parts.AsEnumerable() ).CreateContainer();
			var exports = new ServiceLocator( container ).Get<IEnumerable<IExported>>( typeof(IEnumerable<IExported>) );
			var exported = exports.WhereAssigned().Fixed();
			Assert.Equal( 2, exported.Length );
			Assert.Single( exported.OfType<AnotherExportedClass>() );
			Assert.Single( exported.OfType<ExportedClass>() );
		}
        public void GetServices_WithTypeParameter_IfTheTypeIsConcreteWithParameterlessConstructorAndIfTheTypeIsNotRegistered_ShouldReturnAnEmptyCollection()
        {
            TestHelper.ClearStructureMap();
            TestHelper.AssertStructureMapIsCleared();

            var instances = new ServiceLocator(ObjectFactory.Container).GetServices(typeof(SomeConcreteClassWithParameterlessConstructor)).ToArray();

            Assert.IsNotNull(instances);
            Assert.IsFalse(instances.Any());
        }
        public void ShouldResolveDependencies(Type service, Type implementation)
        {
            var objectUnderTest = new ServiceLocator();

            objectUnderTest.ReplaceBind(typeof (IChineseCharacterTrainerService),
                                        new Mock<IChineseCharacterTrainerService>().Object);

            var instance = objectUnderTest.Get(service);

            Assert.AreEqual(implementation, instance.GetType());
        }
        public void SetUp()
        {
            // Arrange
            SecurityConfigurator.Configure(configuration =>
            {
                configuration.GetAuthenticationStatusFrom(() => true);
            });

            // Act
            _serviceLocator = new ServiceLocator();
        }
        public void Init(ServiceLocator sl, ref PluginSetting setting)
        {
            if (!setting.Enable) return;

            OptimizationModule cm = new OptimizationModule();
            cm.Start();
            sl.AddComponentInstance(cm);

            if (setting["css_sprite"].ToBoolean())
                ImageOptimizations.AddCacheDependencies(ServerUtil.MapPath("~/"), true);
        }
        static void Main(string[] args)
        {
            var serviceLocator = new ServiceLocator();

            var serviceA = serviceLocator.GetService<IServiceA>();
            var serviceB = serviceLocator.GetService<IServiceB>();

            serviceA.Execute();
            serviceB.Execute();

            Console.ReadKey();
        }
        public void GetServices_WithTypeParameter_IfTheTypeIsConcreteWithParameterlessConstructorAndIfTheTypeIsRegistered_ShouldReturnACollectionWithAnInstanceOfThatType()
        {
            TestHelper.ClearStructureMap();
            TestHelper.AssertStructureMapIsCleared();

            ObjectFactory.Initialize(initializer => initializer.For<SomeConcreteClassWithParameterlessConstructor>().Use<SomeConcreteClassWithParameterlessConstructor>());
            var instances = new ServiceLocator(ObjectFactory.Container).GetServices(typeof(SomeConcreteClassWithParameterlessConstructor)).ToArray();

            Assert.IsNotNull(instances);
            Assert.IsTrue(instances.Count() == 1);
            Assert.IsTrue(instances.ElementAt(0) is SomeConcreteClassWithParameterlessConstructor);
        }
Exemple #31
0
 protected void given_remote_config(RemoteRepositories remoteRepositories)
 {
     ServiceLocator.GetService <IConfigurationManager>().Save(ConfiguredRemotes = remoteRepositories);
     ReloadRepositories();
 }
Exemple #32
0
 private void Start() => _audioManager = ServiceLocator.Resolve <AudioManager>();
Exemple #33
0
 public override void Execute()
 {
     ServiceLocator.GetService <CommandManager>().CommandExecute(this);
 }
 public PackageSourcesOptionsControl(IServiceProvider serviceProvider)
     : this(ServiceLocator.GetInstance <ISourceRepositoryProvider>(), serviceProvider)
 {
 }
 public InventoryEditorViewModel(BaseViewModel parentViewModel, InventoryEditorModel dataModel)
     : this(parentViewModel, dataModel, ServiceLocator.Resolve <IDialogService>())
 {
 }
Exemple #36
0
        protected openwrap_context()
        {
            // TODO: Review if we should use the Service registry?
            RemoteRepositories = new List <IPackageRepository>();
            ConfiguredRemotes  = new RemoteRepositories();
            ServiceLocator.Clear();
            var currentDirectory = System.Environment.CurrentDirectory;

            FileSystem  = given_file_system(currentDirectory);
            Environment = new InMemoryEnvironment(
                FileSystem.GetDirectory(currentDirectory),
                FileSystem.GetDirectory(DefaultInstallationPaths.ConfigurationDirectory));
            //Environment.DescriptorFile.MustExist();
            ServiceLocator.RegisterService <IFileSystem>(FileSystem);
            ServiceLocator.RegisterService <IEnvironment>(Environment);
            ServiceLocator.RegisterService <IPackageResolver>(new ExhaustiveResolver());
            ServiceLocator.TryRegisterService <IPackageDeployer>(() => new DefaultPackageDeployer());
            ServiceLocator.TryRegisterService <IPackageExporter>(() => new DefaultPackageExporter(new IExportProvider[] {
                new DefaultAssemblyExporter(),
                new CecilCommandExporter()
            }));
            ServiceLocator.RegisterService <ICommandRepository>(Commands);

            ServiceLocator.TryRegisterService <IPackageManager>(PackageManagerFactory());

            ServiceLocator.RegisterService <IConfigurationManager>(new DefaultConfigurationManager(Environment.ConfigurationDirectory));


            Factory           = new MemoryRepositoryFactory();
            Factory.FromToken = token => RemoteRepositories.FirstOrDefault(repo => repo.Token == token);
            RemoteFactories   = new List <IRemoteRepositoryFactory> {
                Factory
            };

            ServiceLocator.TryRegisterService <IEnumerable <IRemoteRepositoryFactory> >(() => RemoteFactories);

            ConfigurationManager = ServiceLocator.GetService <IConfigurationManager>();
            ConfigurationManager.Save(ConfiguredRemotes);

            ServiceLocator.RegisterService <IRemoteManager>(new DefaultRemoteManager(ConfigurationManager, ServiceLocator.GetService <IEnumerable <IRemoteRepositoryFactory> >()));
        }
Exemple #37
0
 public NuGetPackage()
 {
     ServiceLocator.InitializePackageServiceProvider(this);
 }
Exemple #38
0
        public void TestCreateAndGetNotNullObject()
        {
            var testClassInstance = ServiceLocator.Get <TestClass>();

            Assert.IsNotNull(testClassInstance);
        }
Exemple #39
0
 public static void Main(string[] args)
 {
     ServiceLocator.SetLocatorProvider(ServiceProvider.GetServiceLocator);
     new ServiceApplication().Run(args);
 }
        internal async Task InitializeOnActivatedAsync(CancellationToken cancellationToken)
        {
            try
            {
                if (_initialized)
                {
                    return;
                }

                _initialized = true;

                IServiceBrokerProvider serviceBrokerProvider = await ServiceLocator.GetInstanceAsync <IServiceBrokerProvider>();

                IServiceBroker serviceBroker = await serviceBrokerProvider.GetAsync();

#pragma warning disable ISB001 // Dispose of proxies, disposed in disposing event or in ClearSettings
                _nugetSourcesService = await serviceBroker.GetProxyAsync <INuGetSourcesService>(
                    NuGetServices.SourceProviderService,
                    cancellationToken : cancellationToken);

#pragma warning restore ISB001 // Dispose of proxies, disposed in disposing event or in ClearSettings
                Assumes.NotNull(_nugetSourcesService);

                // get packages sources
                _originalPackageSources = await _nugetSourcesService.GetPackageSourcesAsync(cancellationToken);

                // packageSources and machineWidePackageSources are deep cloned when created, no need to worry about re-querying for sources to diff changes
                var allPackageSources         = _originalPackageSources;
                var packageSources            = allPackageSources.Where(ps => !ps.IsMachineWide).ToList();
                var machineWidePackageSources = allPackageSources.Where(ps => ps.IsMachineWide).ToList();

                // bind to the package sources, excluding Aggregate
                _packageSources = new BindingSource(packageSources.Select(ps => ps.Clone()).ToList(), null);
                _packageSources.CurrentChanged  += OnSelectedPackageSourceChanged;
                PackageSourcesListBox.GotFocus  += PackageSourcesListBox_GotFocus;
                PackageSourcesListBox.DataSource = _packageSources;

                if (machineWidePackageSources.Count > 0)
                {
                    _machineWidepackageSources = new BindingSource(machineWidePackageSources.Select(ps => ps.Clone()).ToList(), null);
                    _machineWidepackageSources.CurrentChanged  += OnSelectedMachineWidePackageSourceChanged;
                    MachineWidePackageSourcesListBox.GotFocus  += MachineWidePackageSourcesListBox_GotFocus;
                    MachineWidePackageSourcesListBox.DataSource = _machineWidepackageSources;
                }
                else
                {
                    MachineWidePackageSourcesListBox.Visible = MachineWideSourcesLabel.Visible = false;
                }

                OnSelectedPackageSourceChanged(null, EventArgs.Empty);
            }
            // Thrown during creating or saving NuGet.Config.
            catch (NuGetConfigurationException ex)
            {
                MessageHelper.ShowErrorMessage(ex.Message, Resources.ErrorDialogBoxTitle);
            }
            // Thrown if no nuget.config found.
            catch (InvalidOperationException ex)
            {
                MessageHelper.ShowErrorMessage(ex.Message, Resources.ErrorDialogBoxTitle);
            }
            catch (UnauthorizedAccessException)
            {
                MessageHelper.ShowErrorMessage(Resources.ShowError_ConfigUnauthorizedAccess, Resources.ErrorDialogBoxTitle);
            }
            // Unknown exception.
            catch (Exception ex)
            {
                MessageHelper.ShowErrorMessage(Resources.ShowError_SettingActivatedFailed, Resources.ErrorDialogBoxTitle);
                ActivityLog.LogError(NuGetUI.LogEntrySource, ex.ToString());
            }
        }
        public IActionResult InfoV1()
        {
            var userPayload = ServiceLocator.Resolve <IApiTokenService>().GetUserPayloadByToken();

            return(Ok(new { status = 1, data = userPayload }));
        }
Exemple #42
0
 public T GetNew <T>()
 {
     return(ServiceLocator.GetInstance <T>());
 }
Exemple #43
0
        protected void given_config <T>(T config)
        {
            var confMan = ServiceLocator.GetService <IConfigurationManager>();

            confMan.Save(config);
        }
Exemple #44
0
 private void Start()
 {
     _gm = ServiceLocator.GetService <GameManager>();
     NetworkingManager.ProccessedCommands += PassCommandsToUnits;
 }
Exemple #45
0
 public void Initialize()
 {
     StateService = ServiceLocator.GetInstance <IStateService>();
 }
Exemple #46
0
 /// <summary>
 /// 初始化一个<see cref="ModuleHandlerBase{TModule, TModuleInputDto, TModuleKey, TModuleFunction}"/>类型的新实例
 /// </summary>
 protected ModuleHandlerBase()
 {
     _locator          = ServiceLocator.Instance;
     _moduleInfoPicker = _locator.GetService <IModuleInfoPicker>();
     Logger            = _locator.GetLogger(GetType());
 }
 public override void ResetServiceLocator()
 {
     ServiceLocator.SetLocatorProvider(() => null);
 }
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     ServiceLocator.RegisterAll();
 }
 public override void SetServiceLocator()
 {
     CheckContainer();
     ServiceLocator.SetLocatorProvider(() => new WindsorServiceLocator(container));
 }
Exemple #50
0
 public LoginController()
 {
     _handler = new LoginHandler(ServiceLocator.GetSoapService());
 }
Exemple #51
0
        private string GetLocalize(string key)
        {
            var    languageService = ServiceLocator.GetService <ILanguageService>();
            var    cultureOption   = ServiceLocator.GetService <IOptions <CultureOption> >();
            string culture         = CultureInfo.CurrentUICulture.Name;

            if (cultureOption != null && cultureOption.Value.Code.IsNotNullAndWhiteSpace())
            {
                culture = cultureOption.Value.Code;
            }
            var language = languageService.Get(key, culture);

            if (language == null)
            {
                string lanValue = key;
                string lanType  = "UnKnown";
                string module   = "Unknown";
                if (key.Contains("@"))
                {
                    lanValue = key.Split('@')[1];
                    var translated = languageService.Get(n => n.LanKey.EndsWith("@" + lanValue) && n.CultureName == culture).FirstOrDefault();
                    if (translated != null)
                    {
                        lanValue = translated.LanValue;
                    }
                    else
                    {
                        StringBuilder lanValueBuilder = new StringBuilder();
                        if (lanValue.Length > 2 && (lanValue.EndsWith("ID") || lanValue.EndsWith("Id")))
                        {
                            lanValue = lanValue.Substring(0, lanValue.Length - 2);
                        }
                        if (lanValue.Length > 2)
                        {
                            for (int i = 0; i < lanValue.Length; i++)
                            {
                                char charLan = lanValue[i];
                                if (i > 0 && char.IsUpper(charLan))
                                {
                                    lanValueBuilder.Append(' ');
                                }
                                lanValueBuilder.Append(charLan);
                            }
                            lanValue = lanValueBuilder.ToString();
                        }
                    }
                    lanType  = "EntityProperty";
                    module   = key.Split('@')[0];
                    language = new LanguageEntity
                    {
                        CultureName = culture,
                        LanValue    = lanValue,
                        LanKey      = key,
                        LanType     = lanType,
                        Module      = module
                    };
                    languageService.Add(language);
                    return(language.LanValue);
                }
                return(key);
            }
            return(language.LanValue);
        }
Exemple #52
0
 private void OnEnable()
 {
     ServiceLocator.SubscribeToControllerEvent(ChangeFactoryLevel);
 }
Exemple #53
0
 public void TestPresetNullDoesNotThrowsException()
 {
     ServiceLocator.Set <TestClass>(null);
 }
Exemple #54
0
        public MyGame()
        {
            // ----- Service Container
            // The MyGame uses a ServiceContainer, which is a simple service locator
            // and Inversion of Control (IoC) container. (The ServiceContainer can be
            // replaced by any other container that implements System.IServiceProvider.)
            _serviceContainer = new ServiceContainer();
            ServiceLocator.SetLocatorProvider(() => _serviceContainer);

            // ----- Storage
            // Create a "virtual file system" for reading game assets.
            var titleStorage       = new TitleStorage("Content");
            var assetsStorage      = new ZipStorage(titleStorage, "Content.zip");
            var digitalRuneStorage = new ZipStorage(titleStorage, "DigitalRune.zip");
            var vfsStorage         = new VfsStorage();

            vfsStorage.MountInfos.Add(new VfsMountInfo(titleStorage, null));
            vfsStorage.MountInfos.Add(new VfsMountInfo(assetsStorage, null));
            vfsStorage.MountInfos.Add(new VfsMountInfo(digitalRuneStorage, null));

            // ----- Content
            _contentManager = new StorageContentManager(ServiceLocator.Current, vfsStorage);
            _serviceContainer.Register(typeof(ContentManager), null, _contentManager);

            // ----- Graphics
            // Create Direct3D 11 device.
            var presentationParameters = new PresentationParameters
            {
                BackBufferWidth  = 1,
                BackBufferHeight = 1,
                // Do not associate graphics device with any window.
                DeviceWindowHandle = IntPtr.Zero,
            };
            var graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, presentationParameters);

            // An IGraphicsDeviceService is required by the MonoGame/XNA content manager.
            _serviceContainer.Register(typeof(IGraphicsDeviceService), null, new DummyGraphicsDeviceManager(graphicsDevice));

            // Create and register the graphics manager.
            _graphicsManager = new GraphicsManager(graphicsDevice, _contentManager);
            _serviceContainer.Register(typeof(IGraphicsService), null, _graphicsManager);

            // ----- Timing
            // We can use the CompositionTarget.Rendering event to trigger our game loop.
            // The CompositionTarget.Rendering event is raised once per frame by WPF.

            // To measure the time that has passed, we use a HighPrecisionClock.
            _clock = new HighPrecisionClock();
            _clock.Start();
            CompositionTarget.Rendering += (s, e) => _clock.Update();

            // The FixedStepTimer reads the clock and triggers the game loop at 60 Hz.
            //_timer = new FixedStepTimer(_clock)
            //{
            //  StepSize = new TimeSpan(166667), // ~60 Hz
            //  AccumulateTimeSteps = false,
            //};
            // The VariableStepTimer reads the clock and triggers the game loop as often
            // as possible.
            _timer              = new VariableStepTimer(_clock);
            _timer.TimeChanged += (s, e) => GameLoop(e.DeltaTime);
            _timer.Start();
        }
 public DeleteOrderOperationMediator()
     : base("Delete Order", "Delete Order", "PresentationLayer/Images/DeleteOrder.png",
            ServiceLocator.Get <OperationScopeContext>(), ServiceLocator.Get <OrdersRepository>())
 {
 }
Exemple #56
0
        public static void SetGlobalUserAttribute()
        {
            var userAttribute = new PopForumsGlobalUserAttribute(ServiceLocator.GetInstance <IUserService>(), ServiceLocator.GetInstance <IUserSessionService>());

            GlobalFilters.Filters.Add(userAttribute);
        }
        public IEnumerable <Project> ShowProjectSelectorWindow(
            string instructionText,
            IPackage package,
            Predicate <Project> checkedStateSelector,
            Predicate <Project> enabledStateSelector)
        {
            if (!_uiDispatcher.CheckAccess())
            {
                // Use Invoke() here to block the worker thread
                object result = _uiDispatcher.Invoke(
                    new Func <string, IPackage, Predicate <Project>, Predicate <Project>, IEnumerable <Project> >(ShowProjectSelectorWindow),
                    instructionText,
                    package,
                    checkedStateSelector,
                    enabledStateSelector);

                return((IEnumerable <Project>)result);
            }

            var viewModel = new SolutionExplorerViewModel(
                ServiceLocator.GetInstance <DTE>().Solution,
                package,
                checkedStateSelector,
                enabledStateSelector);

            // only show the solution explorer window if there is at least one compatible project
            if (viewModel.HasProjects)
            {
                var window = new SolutionExplorer()
                {
                    DataContext = viewModel
                };
                window.InstructionText.Text = instructionText;

                bool?dialogResult = null;
                using (NuGetEventTrigger.Instance.TriggerEventBeginEnd(
                           NuGetEvent.SelectProjectDialogBegin,
                           NuGetEvent.SelectProjectDialogEnd))
                {
                    dialogResult = window.ShowModal();
                }

                if (dialogResult ?? false)
                {
                    return(viewModel.GetSelectedProjects());
                }
                else
                {
                    return(null);
                }
            }
            else
            {
                IEnumerable <FrameworkName> supportedFrameworks = package.GetSupportedFrameworks()
                                                                  .Where(name => name != null && name != VersionUtility.UnsupportedFrameworkName);
                string errorMessage = supportedFrameworks.Any() ?
                                      String.Format(
                    CultureInfo.CurrentCulture,
                    Resources.Dialog_NoCompatibleProject,
                    package.Id,
                    Environment.NewLine + String.Join(Environment.NewLine, supportedFrameworks)) :
                                      String.Format(
                    CultureInfo.CurrentCulture,
                    Resources.Dialog_NoCompatibleProjectNoFrameworkNames,
                    package.Id);

                // if there is no project compatible with the selected package, show an error message and return
                MessageHelper.ShowWarningMessage(errorMessage, title: null);
                return(null);
            }
        }
 public ViewModelLocator()
 {
     ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
     SimpleIoc.Default.Register <MainViewModel>();
 }
Exemple #59
0
 public SparkView()
 {
     _services.OnMissing = type => { return(ServiceLocator.GetInstance(type)); };
 }
Exemple #60
0
 private void OnDisable()
 {
     ServiceLocator.UnsubscribeFromControllerEvent(ChangeFactoryLevel);
 }