/// <summary> /// Create a new instance of IoCUnitContainer /// </summary> public IoCUnityContainer() { _ContainersDictionary = new Dictionary <string, IUnityContainer>(); //Create root container IUnityContainer rootContainer = new UnityContainer(); rootContainer.AddNewExtension <Interception>(); _ContainersDictionary.Add("RootContext", rootContainer); //Create container for real context, child of root container IUnityContainer realAppContainer = rootContainer.CreateChildContainer(); _ContainersDictionary.Add("RealAppContext", realAppContainer); //Create container for testing, child of root container IUnityContainer fakeAppContainer = rootContainer.CreateChildContainer(); _ContainersDictionary.Add("FakeAppContext", fakeAppContainer); ConfigureRootContainer(rootContainer); ConfigureRealContainer(realAppContainer); ConfigureFakeContainer(fakeAppContainer); }
/// <summary> /// Create a new instance of IoCUnitContainer /// </summary> public IoCUnityContainer() { _ContainersDictionary = new Dictionary <string, IUnityContainer>(); //Create root container IUnityContainer rootContainer = new UnityContainer(); _ContainersDictionary.Add("RootContext", rootContainer); //Create container for real context, child of root container IUnityContainer realAppContainer = rootContainer.CreateChildContainer(); _ContainersDictionary.Add("RealAppContext", realAppContainer); //Create container for testing, child of root container IUnityContainer fakeAppContainer = rootContainer.CreateChildContainer(); _ContainersDictionary.Add("FakeAppContext", fakeAppContainer); ConfigureRootContainer(rootContainer); ConfigureRealContainer(realAppContainer); //(CDLTLL) Commented - Probable Dependecies Errors in Windows Azure Cloud (It works in Local Azure-Fabric) // At the moment it is ok, as Moles and fake container is not needed in Azure Production //ConfigureFakeContainer(fakeAppContainer); }
public UnityIoC(string nameDefault) { //Create root container _containersDictionary = new Dictionary <string, IUnityContainer>(); IUnityContainer rootUibasoftContainer = new UnityContainer(); _containersDictionary.Add(RootContext, rootUibasoftContainer); //Create container for real context, child of root container var realAppContainer = rootUibasoftContainer.CreateChildContainer(); _containersDictionary.Add(RealAppContext, realAppContainer); //Create container for testing, child of root container var fakeAppContainer = rootUibasoftContainer.CreateChildContainer(); _containersDictionary.Add(TestAppContext, fakeAppContainer); var defaultContainerConfigurationName = nameDefault; if (!_containersDictionary.ContainsKey(defaultContainerConfigurationName.ToLower())) { throw new InvalidOperationException(LocalizedText.ErrorDefaultContainerContainsKey); } _unityDefaulContainer = _containersDictionary[defaultContainerConfigurationName]; }
private IActionTreeNodePresenter ActionTreeNodePresenterFactory(IAction arg) { IUnityContainer childContainer = _container.CreateChildContainer(); childContainer.RegisterInstance(arg); return(childContainer.Resolve <IActionTreeNodePresenter>()); }
public void Test9() { var c = new UnityContainer(); var s1 = new ServiceCollection().AddOptions(); var s2 = new ServiceCollection().AddOptions(); s1.AddSingleton <ITest1, Test1>(); s2.AddSingleton <ITest1, Test1>(); s1.AddSingleton(typeof(IMygenericTest <>), typeof(MyGenericTest <>)); s2.AddSingleton(typeof(IMygenericTest <>), typeof(MyGenericTest <>)); var sp1 = s1.BuildServiceProvider(c.CreateChildContainer()); var t1 = sp1.GetRequiredService <ITest1>(); var sp2 = s2.BuildServiceProvider(c.CreateChildContainer()); var t2 = sp2.GetRequiredService <ITest1>(); //Works for above, but not below Assert.AreNotSame(t2, t1); Assert.AreNotSame(t2.GetHashCode(), t1.GetHashCode()); var h1 = sp1.GetRequiredService <IMygenericTest <int> >(); var h2 = sp2.GetRequiredService <IMygenericTest <int> >(); Assert.IsNotNull(h1, "notnull"); Assert.AreNotSame(h1, h2, "sameobj"); }
private static void Main(string[] args) { if (args.Length == 0) { args = new[] { "10", "+", "20", "+", "30" }; } using (var container = new UnityContainer()) { Bootstrapper.SetupContainer(container); using (var childContainer = container.CreateChildContainer()) { Bootstrapper.SetupChildContainer(childContainer); PerformCalculationAndWriteResult(args, childContainer); } using (var childContainer = container.CreateChildContainer()) { Bootstrapper.SetupChildContainer(childContainer); PerformCalculationAndWriteResult(args, childContainer); } } }
public void Enumerable_SingletonServicesComeFromRootProvider() { using (IUnityContainer provider = new UnityContainer()) { // Arrange provider.RegisterType <IService, EmailService>(new ContainerControlledLifetimeManager()); EmailService disposableService1; EmailService disposableService2; // Act and Assert using (var scope = provider.CreateChildContainer()) { var service = scope.Resolve <IService>(); disposableService1 = (EmailService)service; Assert.IsFalse(disposableService1.Disposed); } Assert.IsFalse(disposableService1.Disposed); using (var scope = provider.CreateChildContainer()) { var service = scope.Resolve <IService>(); disposableService2 = (EmailService)service; Assert.IsFalse(disposableService2.Disposed); } Assert.IsFalse(disposableService2.Disposed); Assert.AreSame(disposableService1, disposableService2); } }
public static void Init(TestContext context) { var container = new UnityContainer(); var config = new SdkConfiguration("test", "test", "10.27.26.83"); container.RegisterTypes(config); _childContainer1 = container.CreateChildContainer(); _childContainer2 = container.CreateChildContainer(); }
public void ContainerControlledOpenGenericInParentResolvesProperlyInChild() { IUnityContainer parentContainer = new UnityContainer() .RegisterType(typeof(ISomeInterface <>), typeof(MyTypeImplementingSomeInterface <>), new ContainerControlledLifetimeManager()); var childOneObject = parentContainer.CreateChildContainer().Resolve <ISomeInterface <string> >(); var childTwoObject = parentContainer.CreateChildContainer().Resolve <ISomeInterface <string> >(); Assert.AreSame(childOneObject, childTwoObject); }
public static void TestContainerControlledLifetimeManager() { IExample example; using (IUnityContainer container = new UnityContainer()) { container.RegisterType(typeof(IExample), typeof(Example), new ContainerControlledLifetimeManager()); IUnityContainer firstSub = null; IUnityContainer secondSub = null; try { firstSub = container.CreateChildContainer(); secondSub = container.CreateChildContainer(); // all containers share same instance // each resolve returns same instance firstSub.Resolve <IExample>().SayHello(); // run one resolving in other thread and still receive same instance Thread thread = new Thread( () => secondSub.Resolve <IExample>().SayHello()); thread.Start(); container.Resolve <IExample>().SayHello(); example = container.Resolve <IExample>(); thread.Join(); } finally { if (firstSub != null) { firstSub.Dispose(); } if (secondSub != null) { secondSub.Dispose(); } } } try { // exception - instance has been disposed with container example.SayHello(); } catch (ObjectDisposedException ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); }
public void Given_an_open_generic_registration_with_a_container_controlled_lifetime_then_resolving_twice_on_different_children_containers_should_return_the_same_instance() { IUnityContainer container = new UnityContainer(); container.RegisterType(typeof(IOpenGenericSample <,>), typeof(OpenGenericSample <,>), new ContainerControlledLifetimeManager()); var sampleOne = container.CreateChildContainer().Resolve <IOpenGenericSample <int, int> >(); var sampleTwo = container.CreateChildContainer().Resolve <IOpenGenericSample <int, int> >(); Assert.AreSame(sampleOne, sampleTwo); Assert.AreEqual(sampleOne.GetHashCode(), sampleTwo.GetHashCode()); }
public static void TestHierarchicalLifetimeManager() { IExample example; using (IUnityContainer container = new UnityContainer()) { container.RegisterType(typeof(IExample), typeof(Example), new HierarchicalLifetimeManager()); IUnityContainer firstSub = null; IUnityContainer secondSub = null; try { firstSub = container.CreateChildContainer(); secondSub = container.CreateChildContainer(); // each subcontainer has its own instance firstSub.Resolve <IExample>().SayHello(); secondSub.Resolve <IExample>().SayHello(); container.Resolve <IExample>().SayHello(); example = firstSub.Resolve <IExample>(); } finally { if (firstSub != null) { firstSub.Dispose(); } if (secondSub != null) { secondSub.Dispose(); } } } try { // exception - instance has been disposed with container example.SayHello(); } catch (ObjectDisposedException ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); }
public void Test13() { // ReplaceTest.Install(); var c = new UnityContainer(); var cc = c.CreateChildContainer(); cc.AddNewExtension <IOptionsExtension> (); var sc = new ServiceCollection(); sc.AddIdentityServer(o => { o.Events.RaiseErrorEvents = true; }); var sp = sc.BuildServiceProvider(); var test = sp.GetService <IdentityServerOptions>(); Assert.IsNotNull(test); //Passes var sp1 = sc.BuildServiceProvider(cc.CreateChildContainer()); var test1 = sp1.GetService <IdentityServerOptions>(); Assert.IsNotNull(test1); }
public IUnityContainer GetOxiteContainer() { IUnityContainer parentContainer = new UnityContainer(); parentContainer .RegisterInstance(new AppSettingsHelper(ConfigurationManager.AppSettings)) .RegisterInstance(RouteTable.Routes) .RegisterInstance(HostingEnvironment.VirtualPathProvider) .RegisterInstance("RegisterRoutesHandler", typeof(MvcRouteHandler)); foreach (ConnectionStringSettings connectionString in ConfigurationManager.ConnectionStrings) { parentContainer.RegisterInstance(connectionString.Name, connectionString.ConnectionString); } parentContainer .RegisterType <ISiteService, SiteService>() .RegisterType <IPluginService, PluginService>() .RegisterType <IUserService, UserService>() .RegisterType <ITagService, TagService>() .RegisterType <IPostService, PostService>() .RegisterType <ITrackbackOutboundService, TrackbackOutboundService>() .RegisterType <IMessageService, MessageService>() .RegisterType <IPageService, PageService>() .RegisterType <IAreaService, AreaService>() .RegisterType <ILocalizationService, LocalizationService>() .RegisterType <ILanguageService, LanguageService>() .RegisterType <IActionInvoker, OxiteControllerActionInvoker>() .RegisterType <IFormsAuthentication, FormsAuthenticationWrapper>() .RegisterType <ISkinEngine, VirtualPathProviderSkinEngine>() .RegisterType <IViewEngine, OxiteViewEngine>() .RegisterType <IValidationService, ValidationService>() .RegisterType <IRegularExpressions, RegularExpressions>() .RegisterType <IValidator <Comment>, CommentValidator>() .RegisterType <IValidator <UserBase>, UserBaseValidator>() .RegisterType <IValidator <PostSubscription>, PostSubscriptionValidator>() .RegisterType <IValidator <User>, UserValidator>() .RegisterType <IValidator <Site>, SiteValidator>() .RegisterType <IValidator <Area>, AreaValidator>() .RegisterType <IValidator <Post>, PostValidator>() .RegisterType <IValidator <Page>, PageValidator>() .RegisterType <IRegisterRoutes, OxiteRoutes>( new InjectionConstructor( new ResolvedParameter <RouteCollection>(), new ResolvedParameter <AppSettingsHelper>(), new ResolvedParameter <Site>(), new ResolvedParameter <IAreaService>(), new ResolvedParameter <Type>("RegisterRoutesHandler") )); IUnityContainer oxiteContainer = parentContainer.CreateChildContainer(); UnityConfigurationSection config = (UnityConfigurationSection)ConfigurationManager.GetSection("unity"); config.Containers.Default.Configure(oxiteContainer); oxiteContainer.RegisterInstance(oxiteContainer); return(oxiteContainer); }
private static void Main(string[] args) { if (args.Length == 0) { args = new[] { "10", "+", "20", "+", "30", "-", "12" }; } using (var container = new UnityContainer()) { Bootstrapper.SetupContainer(container); try { PerformCalculation(args, container); } catch (Exception exception) { // Since the Minus class is registered only in the child container // the default expression cannot be evaluated on the root container Console.WriteLine(exception); } using (var childContainer = container.CreateChildContainer()) { Bootstrapper.SetupChildContainer(childContainer); PerformCalculation(args, childContainer); } } }
static void Main(string[] args) { //Driver driver = new Driver(new BMW()); //driver.RunCar(); var container = new UnityContainer().RegisterType <ICar, BMW>(new HierarchicalLifetimeManager()); var childContainer = container.CreateChildContainer(); var driver1 = container.Resolve <Driver>(); driver1.RunCar(); var driver2 = container.Resolve <Driver>(); driver2.RunCar(); var driver3 = childContainer.Resolve <Driver>(); driver3.RunCar(); var driver4 = childContainer.Resolve <Driver>(); driver4.RunCar(); }
private static void HierarchicalLifetimeManagerDemo() { Console.WriteLine("\nHierarchicalLifetimeManagerDemo() start"); var container = new UnityContainer(); container.RegisterType <ICar, BMW>(new HierarchicalLifetimeManager()); container.RegisterType <ICarKey, BMWKey>(new HierarchicalLifetimeManager()); var childContainer = container.CreateChildContainer(); var driver1 = container.Resolve <Driver>(); driver1.RunCar(); var driver2 = container.Resolve <Driver>(); driver2.RunCar(); var driver3 = childContainer.Resolve <Driver>(); driver3.RunCar(); var driver4 = childContainer.Resolve <Driver>(); driver4.RunCar(); Console.WriteLine("HierarchicalLifetimeManagerDemo() stop\n"); }
public void HierarchicalLifetimeManager_Child_Not_Equal_To_Parent() { // Create parent container IUnityContainer parentCtr = new UnityContainer(); // Register type in parent container parentCtr.RegisterType <MyObject>(new HierarchicalLifetimeManager()); // Create nested child container in parent container IUnityContainer childCtr = parentCtr.CreateChildContainer(); MyObject parentObject1 = parentCtr.Resolve <MyObject>(); MyObject parentObject2 = parentCtr.Resolve <MyObject>(); Assert.That(parentObject2.GetHashCode(), Is.EqualTo(parentObject1.GetHashCode()), "paren1 != parent2"); MyObject childObject = childCtr.Resolve <MyObject>(); Assert.That(childObject.GetHashCode(), Is.Not.EqualTo(parentObject1.GetHashCode()), "child != parent"); // Dispose child container childCtr.Dispose(); // Dispose parent container parentCtr.Dispose(); }
public void NestedContainerOverrideInParentDoesNotReturnOverridenInChildAcrossCalls() { IToWhichDependent overrideValue = new Type2ToWhichDependent(222); IUnityContainer container = new UnityContainer(); IUnityContainer childContainer = container.CreateChildContainer(); // Registering the parent default types. container.RegisterType <IDependingOnOtherType, Type1DependingOnOtherType>().RegisterType <IToWhichDependent, Type1ToWhichDependent>(new InjectionConstructor(111)); // Overriding the default values for the parent container. Type1DependingOnOtherType parentResult = (Type1DependingOnOtherType)container.Resolve <IDependingOnOtherType>(new DependencyOverride(typeof(IToWhichDependent), overrideValue)); // Resolving child container to the default type. Type1DependingOnOtherType childResult = (Type1DependingOnOtherType)childContainer.Resolve <IDependingOnOtherType>(); // The parent overriden values should be reflected. Assert.IsInstanceOfType(parentResult.IToWhichDependent, typeof(Type2ToWhichDependent)); Assert.IsInstanceOfType(parentResult.OneMoreIToWhichDependent, typeof(Type2ToWhichDependent)); Assert.AreEqual <int>(parentResult.IToWhichDependent.X, 222); // The parent default registered type should be reflected, since there are no type registered exclusively for the child container. Assert.IsInstanceOfType(childResult.IToWhichDependent, typeof(Type1ToWhichDependent)); Assert.IsInstanceOfType(childResult.OneMoreIToWhichDependent, typeof(Type1ToWhichDependent)); Assert.AreEqual <int>(childResult.IToWhichDependent.X, 111); }
static void InitContainers() { /* * CREATE DICTIONARY */ _containersDictionary = new Dictionary <string, IUnityContainer>(); /* * CREATE CONTAINERS */ //Create root container IUnityContainer rootContainer = new UnityContainer(); _containersDictionary.Add("RootContext", rootContainer); //Create container for real context, child of root container var realAppContainer = rootContainer.CreateChildContainer(); _containersDictionary.Add("RealAppContext", realAppContainer); //Create container for testing, child of root container //IUnityContainer fakeAppContainer = rootContainer.CreateChildContainer(); //_containersDictionary.Add("FakeAppContext", fakeAppContainer); /* * CONFIGURE CONTAINERS */ ConfigureRootContainer(rootContainer); //ConfigureRealContainer(realAppContainer); //ConfigureFakeContainer(fakeAppContainer); }
public void ParentContainerResolvesParentNotChild() { IUnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); Assert.AreSame(parent, parent.Resolve <IUnityContainer>()); }
public CollectService() { var diContainer = new UnityContainer().CreateChildContainer(); lock (ScheduleInitLock) { var scheduler = new Quartz.Impl.StdSchedulerFactory().GetScheduler(); if (ScheduleController == null) { SchedulerContainer = diContainer.CreateChildContainer(); scheduler.JobFactory = new UnityJobFactory(SchedulerContainer); ScheduleController = new ScheduleController(scheduler); ScheduleController.ReschedulingAlreadyExecuted = false; } diContainer.RegisterType <IDataProvider, DataProvider>(new ContainerControlledLifetimeManager()); diContainer.RegisterType <ICollectRequestRepository, CollectRequestRepository>(new ContainerControlledLifetimeManager()); diContainer.RegisterType <IProbeManager, ProbeManager>(); diContainer.RegisterType <ICollectRequestAssembler, CollectRequestAssembler>(new ContainerControlledLifetimeManager()); diContainer.RegisterType <ICollectPackageAssembler, CollectPackageAssembler>(new ContainerControlledLifetimeManager()); diContainer.RegisterType <ICollectResultAssembler, CollectResultAssembler>(new ContainerControlledLifetimeManager()); diContainer.RegisterType <IDefinitionDocumentFactory, DefinitionDocumentFactory>(new ContainerControlledLifetimeManager()); diContainer.RegisterInstance <IScheduler>(scheduler); diContainer.RegisterInstance <IScheduleController>(ScheduleController); CollectController = diContainer.Resolve <CollectController>(); } }
public void DependencyOverrideWithNestedContainer() { IToWhichDependent defaultValue = new Type1ToWhichDependent(111); IToWhichDependent overrideValue3 = new Type2ToWhichDependent(333); IToWhichDependent overrideValue4 = new Type2ToWhichDependent(444); IUnityContainer container = new UnityContainer(); IUnityContainer childContainer = container.CreateChildContainer(); // Registering the parent default types. container.RegisterType <IDependingOnOtherType, Type1DependingOnOtherType>().RegisterType <IToWhichDependent, Type1ToWhichDependent>(new InjectionConstructor(111)); // Registering the child default types. childContainer.RegisterType <IDependingOnOtherType, Type1DependingOnOtherType>().RegisterType <IToWhichDependent, Type1ToWhichDependent>(new InjectionConstructor(222)); // Overriding the default values for the parent container. Type1DependingOnOtherType parentResult = (Type1DependingOnOtherType)container.Resolve <IDependingOnOtherType>(new DependencyOverride(typeof(IToWhichDependent), overrideValue3)); // Overriding the default values for the child container. Type1DependingOnOtherType childResult = (Type1DependingOnOtherType)childContainer.Resolve <IDependingOnOtherType>(new DependencyOverride(typeof(IToWhichDependent), overrideValue4)); // The parent overriden values should be reflected. Assert.IsInstanceOfType(parentResult.IToWhichDependent, typeof(Type2ToWhichDependent)); Assert.IsInstanceOfType(parentResult.OneMoreIToWhichDependent, typeof(Type2ToWhichDependent)); Assert.AreEqual <int>(parentResult.IToWhichDependent.X, 333); // The child overriden values should be reflected. Assert.IsInstanceOfType(childResult.IToWhichDependent, typeof(Type2ToWhichDependent)); Assert.IsInstanceOfType(childResult.OneMoreIToWhichDependent, typeof(Type2ToWhichDependent)); Assert.AreEqual <int>(childResult.IToWhichDependent.X, 444); }
public void ChildContainerResolvesChildNotParent() { IUnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); Assert.AreSame(child, child.Resolve <IUnityContainer>()); }
public void Test_CreateChildContainer_ChildAddsInstance_ExpectingChildCanResolveParentsRegistration() { var parentContainer = new UnityContainer(); var i1Mock = new Mock <II1>(); i1Mock.Setup(i1 => i1.f1(1)).Returns(42); parentContainer.RegisterInstance(i1Mock.Object); //parent var i1Obj = parentContainer.Resolve <II1>(); Assert.IsNotNull(i1Obj); Assert.AreEqual(0, i1Obj.f1(0)); Assert.AreEqual(42, i1Obj.f1(1)); //child IUnityContainer childContainer = parentContainer.CreateChildContainer(); i1Obj = childContainer.Resolve <II1>(); Assert.IsNotNull(childContainer.Resolve <II1>()); Assert.AreEqual(0, i1Obj.f1(0)); Assert.AreEqual(42, i1Obj.f1(1)); //parent }
public void MoreChildContainers2() { UnityContainer parent = new UnityContainer(); parent.RegisterType <ITemporary, Temp>("First", new HierarchicalLifetimeManager()); UnityContainer child1 = (UnityContainer)parent.CreateChildContainer(); child1.RegisterType <ITemporary, Temp>("First", new HierarchicalLifetimeManager()); var result = parent.Resolve <ITemporary>("First"); var result1 = child1.Resolve <ITemporary>("First"); Assert.AreNotEqual <int>(result.GetHashCode(), result1.GetHashCode()); UnityContainer child2 = (UnityContainer)child1.CreateChildContainer(); child2.RegisterType <ITemporary, Temp>("First", new HierarchicalLifetimeManager()); var result2 = child2.Resolve <ITemporary>("First"); Assert.AreNotEqual <int>(result.GetHashCode(), result2.GetHashCode()); Assert.AreNotEqual <int>(result1.GetHashCode(), result2.GetHashCode()); List <ITemporary> count = new List <ITemporary>(child2.ResolveAll <ITemporary>()); Assert.AreEqual(1, count.Count); }
public void ChildParentRegisrationOverlapTest() { IUnityContainer container = new UnityContainer(); container.RegisterInstance("str1", "string1"); container.RegisterInstance("str2", "string2"); IUnityContainer child = container.CreateChildContainer(); child.RegisterInstance("str2", "string20"); child.RegisterInstance("str3", "string30"); var childStrList = child.ResolveAll <string>(); var parentStrList = container.ResolveAll <string>(); string childString = String.Empty; string parentString = String.Empty; foreach (string str in childStrList) { childString = childString + str; } foreach (string str1 in parentStrList) { parentString = parentString + str1; } Assert.AreEqual <string>("string1string20string30", childString); Assert.AreEqual <string>("string1string2", parentString); }
public void ResolveAll() { IUnityContainer root = new UnityContainer(); object o1 = new object(); object o2 = new object(); root .RegisterInstance <object>("o1", o1) .RegisterInstance <object>(o1) .RegisterInstance <object>(root) .RegisterInstance <object>("o2", o2); var obj = "child"; var child = root.CreateChildContainer() .RegisterInstance <object>(obj) .RegisterInstance <object>(o1) .RegisterInstance <object>("o2", obj); var results = root.Resolve <object[]>(); var results1 = child.Resolve <object[]>(); Assert.IsNotNull(results); Assert.IsNotNull(results1); Assert.IsInstanceOfType(results, typeof(object[])); }
public void MoreChildContainers1() { UnityContainer parent = new UnityContainer(); parent.RegisterType <ITemporary, Temp>("First"); parent.RegisterType <ITemporary, Temp>("First"); UnityContainer child1 = (UnityContainer)parent.CreateChildContainer(); child1.RegisterType <ITemporary, Temp>("First"); child1.RegisterType <ITemporary, Temp>("First"); UnityContainer child2 = (UnityContainer)child1.CreateChildContainer(); child2.RegisterType <ITemporary, Temp>("First"); child2.RegisterType <ITemporary, Temp>("First"); UnityContainer child3 = (UnityContainer)child2.CreateChildContainer(); child3.RegisterType <ITemporary, Temp>("First"); child3.RegisterType <ITemporary, Temp>("First"); IUnityContainer child4 = child3.CreateChildContainer(); child4.RegisterType <ITemporary, Temp>("First"); ITemporary first = child4.Resolve <ITemporary>("First"); child4.RegisterType <ITemporary, Temp>("First", new ContainerControlledLifetimeManager()); List <ITemporary> count = new List <ITemporary>(child4.ResolveAll <ITemporary>()); Assert.AreEqual(1, count.Count); }
public void Enumerable_ResolvesDifferentInstancesForOpenGenericsWhenResolvingEnumerable() { using (IUnityContainer provider = new UnityContainer()) { // Arrange provider.RegisterType <IService, EmailService>(); provider.RegisterType(typeof(IFoo <>), typeof(Foo <>), "1", new ContainerControlledLifetimeManager()); provider.RegisterType(typeof(IFoo <>), typeof(Foo <>), "2", new ContainerControlledLifetimeManager()); provider.RegisterType(typeof(IFoo <>), typeof(Foo <>), "3", new ContainerControlledLifetimeManager()); using (var scope = provider.CreateChildContainer()) { var enumerable = scope.Resolve <IEnumerable <IFoo <IService> > >().ToArray(); var service = scope.Resolve <IFoo <IService> >("3"); // Assert Assert.AreEqual(3, enumerable.Length); Assert.IsNotNull(enumerable[0]); Assert.IsNotNull(enumerable[1]); Assert.IsNotNull(enumerable[2]); Assert.AreNotSame(enumerable[0], enumerable[1]); Assert.AreNotSame(enumerable[1], enumerable[2]); Assert.AreSame(service, enumerable[2]); } } }
public void NamesRegisteredInParentAppearInChild() { UnityContainer parent = new UnityContainer(); parent.RegisterType<ILogger, SpecialLogger>("special"); IUnityContainer child = parent.CreateChildContainer(); ILogger l = child.Resolve<ILogger>("special"); Assert.IsInstanceOfType(l, typeof(SpecialLogger)); }
public void ChildBuildsUsingParentsConfiguration() { UnityContainer parent = new UnityContainer(); parent.RegisterType<ILogger, MockLogger>(); IUnityContainer child = parent.CreateChildContainer(); ILogger logger = child.Resolve<ILogger>(); Assert.NotNull(logger); AssertExtensions.IsInstanceOfType(logger, typeof(MockLogger)); }
public void ChangeInParentConfigurationIsReflectedInChild() { UnityContainer parent = new UnityContainer(); parent.RegisterType<ILogger, MockLogger>(); IUnityContainer child = parent.CreateChildContainer(); ILogger first = child.Resolve<ILogger>(); parent.RegisterType<ILogger, SpecialLogger>(); ILogger second = child.Resolve<ILogger>(); AssertExtensions.IsInstanceOfType(first, typeof(MockLogger)); AssertExtensions.IsInstanceOfType(second, typeof(SpecialLogger)); }
public void NamesRegisteredInParentAppearInChildGetAll() { string[] databases = { "northwind", "adventureworks", "fabrikam" }; UnityContainer parent = new UnityContainer(); parent.RegisterInstance<string>("nwnd", databases[0]) .RegisterInstance<string>("advwks", databases[1]); IUnityContainer child = parent.CreateChildContainer() .RegisterInstance<string>("fbkm", databases[2]); List<string> dbs = new List<string>(child.ResolveAll<string>()); CollectionAssert.AreEquivalent(databases, dbs); }
public void ChildConfigurationOverridesParentConfiguration() { UnityContainer parent = new UnityContainer(); parent.RegisterType<ILogger, MockLogger>(); IUnityContainer child = parent.CreateChildContainer() .RegisterType<ILogger, SpecialLogger>(); ILogger parentLogger = parent.Resolve<ILogger>(); ILogger childLogger = child.Resolve<ILogger>(); Assert.IsInstanceOfType(parentLogger, typeof(MockLogger)); Assert.IsInstanceOfType(childLogger, typeof(SpecialLogger)); }
public void CanDisposeChildWithoutDisposingParent() { DisposableObject parentSpy = new DisposableObject(); DisposableObject childSpy = new DisposableObject(); UnityContainer parent = new UnityContainer(); parent.RegisterInstance(parentSpy); IUnityContainer child = parent.CreateChildContainer() .RegisterInstance(childSpy); child.Dispose(); Assert.False(parentSpy.WasDisposed); Assert.True(childSpy.WasDisposed); childSpy.WasDisposed = false; parent.Dispose(); Assert.True(parentSpy.WasDisposed); Assert.False(childSpy.WasDisposed); }
public void DisposingParentDisposesChild() { UnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); DisposableObject spy = new DisposableObject(); child.RegisterInstance<DisposableObject>(spy); parent.Dispose(); Assert.True(spy.WasDisposed); }
public void ChildExtensionDoesntAffectParent() { bool factoryWasCalled = false; UnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer() .RegisterType<object>(new InjectionFactory(c => { factoryWasCalled = true; return new object(); })); parent.Resolve<object>(); Assert.False(factoryWasCalled); child.Resolve<object>(); Assert.True(factoryWasCalled); }
public void FactoryRecievesCurrentContainerWhenUsingChildWhenUsingInjectionFactory() { bool factoryWasCalled = false; IUnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); parent.RegisterType<MockDatabase>( new InjectionFactory(c => { factoryWasCalled = true; Assert.AreSame(child, c); return MockDatabase.Create("connectionString"); })); child.Resolve<MockDatabase>(); Assert.IsTrue(factoryWasCalled); }
public void FactoryRecievesCurrentContainerWhenUsingChild() { IUnityContainer parent = new UnityContainer(); IUnityContainer child = parent.CreateChildContainer(); parent .AddNewExtension<StaticFactoryExtension>() .Configure<StaticFactoryExtension>() .RegisterFactory<MockDatabase>( c => { Assert.AreSame(child, c); return MockDatabase.Create("connectionString"); }); var db = child.Resolve<MockDatabase>(); }
public void ContainerRaisesChildContainerCreatedToExtension() { bool childContainerEventRaised = false; var mockExtension = new MockContainerExtension(); var container = new UnityContainer() .AddExtension(mockExtension); mockExtension.Context.ChildContainerCreated += (sender, ev) => { childContainerEventRaised = true; }; var child = container.CreateChildContainer(); Assert.IsTrue(childContainerEventRaised); }
public void ChildContainerCreatedEventGivesChildContainerToExtension() { var mockExtension = new MockContainerExtension(); ExtensionContext childContext = null; var container = new UnityContainer() .AddExtension(mockExtension); mockExtension.Context.ChildContainerCreated += (sender, ev) => { childContext = ev.ChildContext; }; var child = container.CreateChildContainer(); Assert.AreSame(child, childContext.Container); }