public void WhenInstanceRegisteredAsSingletonThenGetSameInstance() { var factory = new SimpleServiceContainer(); var myInstance = new MyService(); factory.RegisterSingleton <IMyService>(myInstance); var actual = factory.GetInstance <IMyService>(); actual.Should().Be.SameInstanceAs(myInstance); }
static SharedDicTestContext() { _allPlugins = new List <INamedVersionedUniqueId>(); _allPluginsEx = new ReadOnlyListOnIList <INamedVersionedUniqueId>(_allPlugins); EnsurePlugins(10); var c = new SimpleServiceContainer(); c.Add <ISimpleTypeFinder>(SimpleTypeFinder.Default); _serviceProvider = c; }
public static void RegisterAllServices(this SimpleServiceContainer store) { var repoFactory = new GenericRepositoryFactory(store, store); store.RegisterSingleton <IRepositoryFactory>(c => repoFactory); var reports = new ReportsProvider(); store.RegisterSingleton <IReportsProvider>(reports); store.RegisterSingleton <IReportsStore>(reports); RegisterRepositories(repoFactory); }
public void WhenTransientServiceThenGetNewInstance() { var factory = new SimpleServiceContainer(); factory.RegisterTransient <IMyService>(x => new MyService()); var first = factory.GetInstance <IMyService>(); var actual = factory.GetInstance <IMyService>(); actual.Should().Not.Be.SameInstanceAs(first); }
public void registering_a_simple_class() { ISimpleServiceContainer container = new SimpleServiceContainer(); ProvidedClass providedClass = new ProvidedClass(5); container.Add(providedClass); ProvidedClass retrievedObject = container.GetService <ProvidedClass>(); retrievedObject.Should().NotBeNull(); retrievedObject.Age.Should().Be(5); }
public void registering_a_simple_class() { ISimpleServiceContainer container = new SimpleServiceContainer(); ProvidedClass providedClass = new ProvidedClass(5); container.Add(providedClass); ProvidedClass retrievedObject = container.GetService <ProvidedClass>(); Assert.That(retrievedObject, Is.Not.Null); Assert.That(retrievedObject.Age, Is.EqualTo(5)); }
GitFolder(Repository r, ProtoGitFolder data) : base(data, r, data.FullPhysicalPath, data.FolderPath) { _headFolder = new HeadFolder(this); _branchesFolder = new BranchesFolder(this, "branches", isRemote: false); _remoteBranchesFolder = new RemotesFolder(this); _thisDir = new RootDir(this, SubPath.LastPart); ServiceContainer = new SimpleServiceContainer(FileSystem.ServiceContainer); ServiceContainer.Add(this); PluginManager = new GitPluginManager(data.PluginRegistry, ServiceContainer, data.CommandRegister, data.World.DevelopBranchName); data.CommandRegister.Register(this); }
public GenBinPath(StObjEngineRunContext global, StObjCollectorResult result, RunningBinPathGroup group) { Debug.Assert(!result.HasFatalError); _global = global; Result = result; ConfigurationGroup = group; Memory = new Dictionary <object, object?>(); ServiceContainer = new SimpleServiceContainer(_global.ServiceContainer); ServiceContainer.Add(result.DynamicAssembly.GetPocoSupportResult()); }
/// <summary> /// Initializes a new plugin manager. /// </summary> /// <param name="registry">The registry of plugins.</param> /// <param name="baseProvider">The base service provider.</param> /// <param name="commandRegister">Command registerer.</param> /// <param name="defaultBranchName">The default branch name (typically "develop"). Must not be null or empty.</param> public GitPluginManager(GitPluginRegistry registry, ISimpleServiceContainer baseProvider, CommandRegister commandRegister, string defaultBranchName) { if (String.IsNullOrWhiteSpace(defaultBranchName)) { throw new ArgumentNullException(nameof(defaultBranchName)); } ServiceContainer = new SimpleServiceContainer(baseProvider); _defaultBranchName = defaultBranchName; _commandRegister = commandRegister ?? throw new ArgumentNullException(nameof(commandRegister)); Registry = registry; _plugins = new PluginCollection <IGitPlugin>(this, null); _branches = new Branches(this); }
public void DoTest() { var extraServices = new SimpleServiceContainer(); extraServices.Add <Func <string> >(() => "Hello World!"); StObjCollector collector = new StObjCollector(TestHelper.Monitor, extraServices); collector.RegisterType(typeof(JustForTheAttribute)); var r = collector.GetResult(); Assert.That(r.HasFatalError, Is.False); }
public WriterImpl(XmlWriter writer, IServiceProvider baseServiceProvider, bool writeElementHeader, bool autoCloseWriter) : base(null) { _xmlWriter = writer; _serviceContainer = new SimpleServiceContainer(baseServiceProvider); if (writeElementHeader) { Xml.WriteStartElement("CK-Structured"); Xml.WriteAttributeString("version", "2.5.5"); _mustEndElement = true; } _mustCloseWriter = autoCloseWriter; Current = this; }
internal StObjEngineConfigureContext(IActivityMonitor monitor, RunningStObjEngineConfiguration config, IStObjEngineStatus status, bool canSkipRun) { _monitor = monitor; _config = config; _status = status; _aspects = new List <IStObjEngineAspect>(); _configurator = new StObjEngineConfigurator(); _container = new Container(this); _configureOnlycontainer = new SimpleServiceContainer(_container); _trampoline = new StObjEngineAspectTrampoline <IStObjEngineConfigureContext>(this); _canSkipRun = canSkipRun; }
public void SimpleServiceContainerGetDirectServiceTest() { SimpleServiceContainer container = new SimpleServiceContainer(); Assert.That(container.GetService <IServiceProvider>() == container); Assert.That(container.GetService <ISimpleServiceContainer>() == container); Assert.Throws <CKException>(() => container.Add <ISimpleServiceContainer>(container)); Assert.Throws <CKException>(() => container.Add <ISimpleServiceContainer>(new SimpleServiceContainer())); Assert.Throws <CKException>(() => container.AddDisabled(typeof(ISimpleServiceContainer))); Assert.Throws <CKException>(() => container.Add <IServiceProvider>(container)); Assert.Throws <CKException>(() => container.Add <IServiceProvider>(new SimpleServiceContainer())); Assert.Throws <CKException>(() => container.AddDisabled(typeof(IServiceProvider))); }
/// <summary> /// Initializes a new <see cref="FileSystem"/> on a physical root path. /// </summary> /// <param name="rootPath">Physical root path.</param> /// <param name="commandRegister">Command register.</param> /// <param name="sp">Optional base services.</param> public FileSystem( string rootPath, CommandRegister commandRegister, SecretKeyStore secretKeyStore, IServiceProvider sp) { Root = new NormalizedPath(Path.GetFullPath(rootPath)); _commandRegister = commandRegister; _secretKeyStore = secretKeyStore; _protoGits = new List <ProtoGitFolder>(); _gits = new List <GitFolder>(); ServiceContainer = new SimpleServiceContainer(sp); ServiceContainer.Add(this); ServiceContainer.Add <IFileProvider>(this); }
public static void Register(HttpConfiguration config) { config.MapHttpAttributeRoutes(); var container = new SimpleServiceContainer(); container.RegisterAllServices(); config.UseSimpleDependencyResolver(container); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api1/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public void SimpleServiceContainerTest() { int removedServicesCount = 0; IServiceContainerConformanceTest(new SimpleServiceContainer()); ISimpleServiceContainer baseProvider = new SimpleServiceContainer(); IMultService multService = new MultServiceImpl(); baseProvider.Add(typeof(IMultService), multService, o => removedServicesCount++); ISimpleServiceContainer container = new SimpleServiceContainer(baseProvider); IServiceContainerConformanceTest(container, baseProvider, baseProvider.GetService <IMultService>()); Assert.That(removedServicesCount, Is.EqualTo(1)); }
public void SimpleServiceContainer_exposes_its_own_IServiceProvier_and_ISimpleServiceContainer_implementation() { SimpleServiceContainer container = new SimpleServiceContainer(); container.GetService <IServiceProvider>().Should().BeSameAs(container); container.GetService <ISimpleServiceContainer>().Should().BeSameAs(container); container.Invoking(sut => sut.Add <ISimpleServiceContainer>(container)).Should().Throw <Exception>(); container.Invoking(sut => sut.Add <ISimpleServiceContainer>(new SimpleServiceContainer())).Should().Throw <Exception>(); container.Invoking(sut => sut.Add <ISimpleServiceContainer>(JustAFunc <ISimpleServiceContainer>)).Should().Throw <Exception>(); container.Invoking(sut => sut.Add <IServiceProvider>(container)).Should().Throw <Exception>(); container.Invoking(sut => sut.Add <IServiceProvider>(new SimpleServiceContainer())).Should().Throw <Exception>(); container.Invoking(sut => sut.Add <IServiceProvider>(JustAFunc <IServiceProvider>)).Should().Throw <Exception>(); container.Invoking(sut => sut.AddDisabled(typeof(IServiceProvider))).Should().Throw <Exception>(); }
public void SimpleServiceContainer_exposes_its_own_IServiceProvier_and_ISimpleServiceContainer_implementation() { SimpleServiceContainer container = new SimpleServiceContainer(); Assert.That(container.GetService <IServiceProvider>() == container); Assert.That(container.GetService <ISimpleServiceContainer>() == container); Assert.Throws <CKException>(() => container.Add <ISimpleServiceContainer>(container)); Assert.Throws <CKException>(() => container.Add <ISimpleServiceContainer>(new SimpleServiceContainer())); Assert.Throws <CKException>(() => container.Add <ISimpleServiceContainer>(JustAFunc <ISimpleServiceContainer>)); Assert.Throws <CKException>(() => container.Add <IServiceProvider>(container)); Assert.Throws <CKException>(() => container.Add <IServiceProvider>(new SimpleServiceContainer())); Assert.Throws <CKException>(() => container.Add <IServiceProvider>(JustAFunc <IServiceProvider>)); Assert.Throws <CKException>(() => container.AddDisabled(typeof(IServiceProvider))); }
public void checking_null_arguments() { ISimpleServiceContainer container = new SimpleServiceContainer(); //SimpleServiceContainer.Add( Type serviceType, object serviceInstance, Action<Object> onRemove = null ) Assert.Throws <ArgumentNullException>(() => container.Add(null, new ProvidedClass(5))); Assert.Throws <ArgumentNullException>(() => container.Add(typeof(ProvidedClass), (object)null)); //SimpleServiceContainer.Add( Type serviceType, Func<Object> serviceInstance, Action<Object> onRemove = null ) Assert.Throws <ArgumentNullException>(() => container.Add(null, JustAFunc)); Assert.Throws <ArgumentNullException>(() => container.Add(typeof(ProvidedClass), (Func <Object>)null)); Assert.Throws <ArgumentNullException>(() => container.AddDisabled(null)); Assert.Throws <ArgumentNullException>(() => container.GetService(null)); Assert.Throws <ArgumentNullException>(() => container.Add <ProvidedClass>(JustAFunc <ProvidedClass>, null)); }
public void registering_an_implementation() { int removedServicesCount = 0; IServiceContainerConformanceTest(new SimpleServiceContainer()); ISimpleServiceContainer baseProvider = new SimpleServiceContainer(); IMultService multService = new MultServiceImpl(); multService.Mult(3, 7).Should().Be(21); baseProvider.Add(typeof(IMultService), multService, o => removedServicesCount++); ISimpleServiceContainer container = new SimpleServiceContainer(baseProvider); IServiceContainerConformanceTest(container, baseProvider, baseProvider.GetService <IMultService>()); removedServicesCount.Should().Be(1); }
private bool HandleStObjPropertySource(IActivityMonitor monitor, StObjProperty p, MutableItem source, string sourceName, bool doSetOrMerge) { StObjProperty?c = source.GetStObjProperty(p.Name); // Source property is defined somewhere in the source. if (c != null) { // If the property is explicitly defined (Info != null) and its type is not // compatible with our, there is a problem. if (c.InfoOnType != null && !p.Type.IsAssignableFrom(c.Type)) { // It is a warning because if actual values work, everything is okay... but one day, it should fail. var msg = String.Format("StObjProperty '{0}.{1}' of type '{2}' is not compatible with the one of its {6} ('{3}.{4}' of type '{5}'). Type should be compatible since {6}'s property value will be propagated if no explicit value is set for '{7}.{1}' or if '{3}.{4}' is set with an incompatible value.", ToString(), p.Name, p.Type.Name, source.RealObjectType.Type.Name, c.Name, c.Type.Name, sourceName, RealObjectType.Type.Name); monitor.Warn(msg); } if (doSetOrMerge) { // The source value must have been set and not explicitly "removed" with a System.Type.Missing value. if (c.Value != System.Type.Missing) { // We "Set" the value from this source. if (!p.ValueHasBeenSet) { p.Value = c.Value; } else if (p.Value is IMergeable) { using (var services = new SimpleServiceContainer()) { services.Add(monitor); if (!((IMergeable)p.Value).Merge(c.Value, services)) { monitor.Error($"Unable to merge StObjProperty '{ToString()}.{p.Value}' with value from {sourceName}."); } } } return(true); } } } return(false); }
public void delegated_attribute_handles_constructor_injection_instead_of_initialization() { OneCtorAttributeImpl.Constructed = false; var aspectProvidedServices = new SimpleServiceContainer(); // Registers this AttributeTests. aspectProvidedServices.Add(this); var c = new StObjCollector(TestHelper.Monitor, aspectProvidedServices); c.RegisterType(typeof(S4)); var r = TestHelper.GetSuccessfulResult(c); Debug.Assert(r.EngineMap != null); r.EngineMap.AllTypesAttributesCache.Values.Should().Contain(a => a.Type == typeof(S4)); OneCtorAttributeImpl.Constructed.Should().BeTrue(); }
public void WriteReadUserConfig() { string path = Path.Combine(TestFolder, "UserConfig.xml"); Guid id = new Guid("{6AFBAE01-5CD1-4EDE-BB56-4590C5A253DF}"); // Write ---------------------------------------------------------- { ISharedDictionary dic = SharedDictionary.Create(null); IConfigManagerExtended config = ConfigurationManager.Create(dic); Assert.That(config, Is.Not.Null); Assert.That(config.HostUserConfig, Is.Not.Null); Assert.That(config.ConfigManager.UserConfiguration, Is.Not.Null); config.HostUserConfig["key1"] = "value1"; config.HostUserConfig["key2"] = "value2"; config.HostUserConfig["key3"] = "value3"; config.ConfigManager.UserConfiguration.PluginsStatus.SetStatus(id, ConfigPluginStatus.AutomaticStart); Assert.That(config.IsUserConfigDirty); Assert.That(config.IsSystemConfigDirty, Is.False); using (Stream wrt = new FileStream(path, FileMode.Create)) using (IStructuredWriter sw = SimpleStructuredWriter.CreateWriter(wrt, null)) { config.SaveUserConfig(sw); } } // Read ------------------------------------------------------------ { ISimpleServiceContainer container = new SimpleServiceContainer(); ISharedDictionary dic = SharedDictionary.Create(container); IConfigManagerExtended config = ConfigurationManager.Create(dic); using (Stream str = new FileStream(path, FileMode.Open)) using (IStructuredReader sr = SimpleStructuredReader.CreateReader(str, container)) { config.LoadUserConfig(sr); } Assert.That(config.HostUserConfig["key1"], Is.EqualTo("value1")); Assert.That(config.HostUserConfig["key2"], Is.EqualTo("value2")); Assert.That(config.HostUserConfig["key3"], Is.EqualTo("value3")); Assert.That(config.ConfigManager.UserConfiguration.PluginsStatus.GetStatus(id, ConfigPluginStatus.Disabled) == ConfigPluginStatus.AutomaticStart); } }
private static void InitServices() { var serviceContainer = new SimpleServiceContainer(); GlobalConfig.ServiceLocator = serviceContainer; GlobalConfig.ErrorReportSerializer = new FormErrorReportSerializer(); var errorReportQueue = new ErrorQueue(); serviceContainer.AddService(typeof(IWebRequestCreate), new WebRequestFactory()); serviceContainer.AddService(typeof(IErrorReportSerializer), (container, type) => GlobalConfig.ErrorReportSerializer); serviceContainer.AddService(typeof(IReportRequestBuilder), (container, type) => new ReportRequestBuilder()); serviceContainer.AddService(typeof(IErrorReportStorage), (container, type) => new RemoteErrorReportStorage()); serviceContainer.AddService(typeof(IErrorReportStorage), (container, type) => new LocalErrorReportStorage()); serviceContainer.AddService(typeof(IErrorQueue), errorReportQueue); var errorHandler = new ErrorHandler(); serviceContainer.AddService(typeof(IErrorHandler), errorHandler); }
public void OneObjectDirectProperty() { var container = new SimpleServiceContainer(); { StObjCollector collector = new StObjCollector(TestHelper.Monitor, container); collector.RegisterType(typeof(SimpleObjectDirect)); var map = collector.GetResult().EngineMap; Debug.Assert(map != null, "No initialization error."); map.StObjs.Obtain <SimpleObjectDirect>() !.OneIntValue.Should().Be(3712, "Direct properties can be set by Attribute."); } { StObjCollector collector = new StObjCollector(TestHelper.Monitor, container, configurator: new ConfiguratorOneIntValueSetTo42()); collector.RegisterType(typeof(SimpleObjectDirect)); var map = collector.GetResult().EngineMap; Debug.Assert(map != null, "No initialization error."); map.StObjs.Obtain <SimpleObjectDirect>() !.OneIntValue.Should().Be(42, "Direct properties can be set by any IStObjStructuralConfigurator participant (here the global one)."); } }
public void SimpleServiceContainerRemoveFallbackTest() { SimpleServiceContainer container = new SimpleServiceContainer(); DisposableClass disposableClass = new DisposableClass(); disposableClass.ServiceContainer = container; container.Add <DisposableClass>(disposableClass, Util.ActionDispose); DisposableClass service = container.GetService <DisposableClass>(); Assert.That(service != null); Assert.That(service.GetType(), Is.EqualTo(typeof(DisposableClass))); container.Clear(); Assert.That(container.GetService(typeof(DisposableClass)), Is.Null); Assert.That(container.GetService <DisposableClass>(), Is.Null); Assert.Throws <CKException>(() => container.GetService <DisposableClass>(true)); }
public void OneObjectAmbientProperty() { var container = new SimpleServiceContainer(); { StObjCollector collector = new StObjCollector(TestHelper.Monitor, container); collector.RegisterType(typeof(SimpleObjectAmbient)); var map = collector.GetResult().EngineMap; Debug.Assert(map != null, "No initialization error."); map.StObjs.OrderedStObjs.Should().NotBeEmpty("We registered SimpleObjectAmbient."); map.StObjs.Obtain <SimpleObjectAmbient>() !.OneIntValue.Should().Be(3712, "Same as Direct properties (above) regarding direct setting. The difference between Ambient and non-ambient lies in value propagation."); } { StObjCollector collector = new StObjCollector(TestHelper.Monitor, container, configurator: new ConfiguratorOneIntValueSetTo42()); collector.RegisterType(typeof(SimpleObjectAmbient)); var map = collector.GetResult().EngineMap; Debug.Assert(map != null, "No initialization error."); map.StObjs.Obtain <SimpleObjectAmbient>() !.OneIntValue.Should().Be(42, "Same as Direct properties (above) regarding direct setting. The difference between Ambient and non-ambient lies in value propagation."); } }
public void clearing_a_container_disposes_all_its_registered_IDisposable_objects_and_remove_reentrancy_is_handled() { SimpleServiceContainer container = new SimpleServiceContainer(); DisposableThatReenterClearWhenDisposed disposableClass = new DisposableThatReenterClearWhenDisposed(); disposableClass.ServiceContainer = container; container.Add(disposableClass, Util.ActionDispose); DisposableThatReenterClearWhenDisposed service = container.GetService <DisposableThatReenterClearWhenDisposed>(); service.Should().NotBeNull(); service.GetType().Should().Be(typeof(DisposableThatReenterClearWhenDisposed)); container.Clear(); container.GetService(typeof(DisposableThatReenterClearWhenDisposed)).Should().BeNull(); container.GetService <DisposableThatReenterClearWhenDisposed>().Should().BeNull(); container.Invoking(sut => sut.GetService <DisposableThatReenterClearWhenDisposed>(true)).Should().Throw <Exception>(); }
public void clearing_a_container_disposes_all_its_registered_IDisposable_objects_and_remove_reentrancy_is_handled() { SimpleServiceContainer container = new SimpleServiceContainer(); DisposableThatReenterClearWhenDisposed disposableClass = new DisposableThatReenterClearWhenDisposed(); disposableClass.ServiceContainer = container; container.Add(disposableClass, Util.ActionDispose); DisposableThatReenterClearWhenDisposed service = container.GetService <DisposableThatReenterClearWhenDisposed>(); Assert.That(service != null); Assert.That(service.GetType(), Is.EqualTo(typeof(DisposableThatReenterClearWhenDisposed))); container.Clear(); Assert.That(container.GetService(typeof(DisposableThatReenterClearWhenDisposed)), Is.Null); Assert.That(container.GetService <DisposableThatReenterClearWhenDisposed>(), Is.Null); Assert.Throws <CKException>(() => container.GetService <DisposableThatReenterClearWhenDisposed>(true)); }
public void using_onRemove_action_reentrancy_of_remove_is_handled() { SimpleServiceContainer container = new SimpleServiceContainer(); DisposableThatReenterClearWhenDisposed disposableClass = new DisposableThatReenterClearWhenDisposed(); EmptyClass stupidObject = new EmptyClass(); disposableClass.ServiceContainer = container; container.Add(disposableClass, Util.ActionDispose); container.Add(stupidObject, e => container.Clear()); DisposableThatReenterClearWhenDisposed service = container.GetService <DisposableThatReenterClearWhenDisposed>(); Assert.That(service, Is.InstanceOf <DisposableThatReenterClearWhenDisposed>()); container.Remove <EmptyClass>(); Assert.That(container.GetService(typeof(DisposableThatReenterClearWhenDisposed)), Is.Null); Assert.That(container.GetService <DisposableThatReenterClearWhenDisposed>(), Is.Null); Assert.Throws <CKException>(() => container.GetService <DisposableThatReenterClearWhenDisposed>(true)); }
public void removing_a_registered_service() { int removedServicesCount = 0; SimpleServiceContainer container = new SimpleServiceContainer(); container.Add(typeof(IAddService), new AddServiceImpl(), o => removedServicesCount++); IAddService service = container.GetService <IAddService>(); Assert.That(service, Is.InstanceOf <AddServiceImpl>()); Assert.That(removedServicesCount, Is.EqualTo(0)); container.Remove(typeof(IAddService)); Assert.That(removedServicesCount, Is.EqualTo(1)); Assert.That(container.GetService(typeof(IAddService)), Is.Null); Assert.That(container.GetService <IAddService>(), Is.Null); Assert.Throws <CKException>(() => container.GetService <IAddService>(true)); }
public void SetUp() { container = new SimpleServiceContainer(); }