public void Combined_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>("transient", new DisposingTransientLifetimeManager()); container.RegisterType<DisposableClass>("shared", new DisposingSharedLifetimeManager()); var transient1 = container.Resolve<DisposableClass>("transient"); var transient2 = container.Resolve<DisposableClass>("transient"); Assert.AreNotEqual(transient1, transient2); var shared1 = container.Resolve<DisposableClass>("shared"); Assert.AreNotEqual(transient1, shared1); Assert.AreNotEqual(transient2, shared1); var shared2 = container.Resolve<DisposableClass>("shared"); Assert.AreEqual(shared1, shared2); container.Teardown(transient1); Assert.IsTrue(transient1.Disposed); container.Teardown(shared2); Assert.IsFalse(shared2.Disposed); container.Teardown(shared1); Assert.IsTrue(shared1.Disposed); }
private void UnityWithConfiguration() { // Create and populate a new Unity container from configuration UnityConfigurationSection UnityConfigurationSectionObject = (UnityConfigurationSection)ConfigurationManager.GetSection("UnityBlockConfiguration"); IUnityContainer UnityContainerObject = new UnityContainer(); UnityConfigurationSectionObject.Containers["ContainerOne"].Configure(UnityContainerObject); Console.WriteLine("\nRetrieved the populated Unity Container."); // Get the logger to write a message and display the result. No name in config file. ILogger ILoggerInstance = UnityContainerObject.Resolve < ILogger>(); Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO Default UNITY!")); // Resolve an instance of the appropriate class registered for ILogger // Using the specified mapping name in the configuration file (may be empty for the default mapping) ILoggerInstance = UnityContainerObject.Resolve<ILogger>("StandardLoggerMappedInConfig"); // Get the logger to write a message and display the result Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO StandardLogger!")); // Resolve an instance of the appropriate class registered for ILogger // Using the specified mapping name (may be empty for the default mapping) ILoggerInstance = UnityContainerObject.Resolve<ILogger>("SuperFastLoggerMappedInConfig"); // Get the logger to write a message and display the result Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO SuperFastLogger!")); // Constructor Injection. // Resolve an instance of the concrete MyObjectWithInjectedLogger class // This class contains a reference to ILogger in the constructor parameters MyObjectWithInjectedLogger MyObjectWithInjectedLoggerInstance = UnityContainerObject.Resolve<MyObjectWithInjectedLogger>(); // Get the injected logger to write a message and display the result Console.WriteLine("\n" + MyObjectWithInjectedLoggerInstance.GetObjectStringResult()); // Throws error as we are trying to create instance for interface. //IMyInterface IMyInterfaceObject = UnityContainerObject.Resolve<IMyInterface>(); IMyInterface IMyInterfaceObject = UnityContainerObject.Resolve<IMyInterface>(); Console.WriteLine("\n" + IMyInterfaceObject.GetObjectStringResult()); //If we are not sure whether a named registration exists for an object, // we can use the ResolveAll method to obtain a list of registrations and mappings, and then check for the object we need in the list returned by this method. // However, this will cause the container to generate all the objects for all named registrations for the specified object type, which will affect performance. IEnumerable<object> IEnumerableObjects = UnityContainerObject.ResolveAll(typeof(ILogger)); int i = 0; foreach (ILogger foundObject in IEnumerableObjects) { // Convert the object reference to the "real" type ILogger theObject = foundObject as ILogger; i++; if (null != theObject) { Console.WriteLine(theObject.WriteMessage("Reading Object " + i.ToString())); } } UnityContainerObject.Teardown(IMyInterfaceObject); Console.ReadLine(); }
public void MassDisposable_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingTransientLifetimeManager()); var sw = new Stopwatch(); sw.Start(); var objects = new List<DisposableClass>(); for (int i = 0; i < 10000; i++) { objects.Add(container.Resolve<DisposableClass>()); } sw.Stop(); Context.WriteLine("Resolve: " + sw.Elapsed.ToString()); sw.Restart(); for (int i = 0; i < 10000; i++) { container.Teardown(objects[i]); Assert.IsTrue(objects[i].Disposed); } sw.Stop(); Context.WriteLine("Teardown: " + sw.Elapsed.ToString()); }
public void TransientParentWithSharedChild_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<ClassWithDisposable>(new DisposingTransientLifetimeManager()); container.RegisterType<DisposableClass>(new DisposingSharedLifetimeManager()); var obj1 = container.Resolve<ClassWithDisposable>(); var obj2 = container.Resolve<ClassWithDisposable>(); container.Teardown(obj1); Assert.IsFalse(obj2.Disposable.Disposed); container.Teardown(obj2); Assert.IsTrue(obj2.Disposable.Disposed); }
public void ClassWithTwoDisposables_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingSharedLifetimeManager()); var obj1 = container.Resolve<ClassWithTwoDisposables>(); Assert.AreEqual(obj1.Disposable, obj1.Disposable2); var obj2 = container.Resolve<ClassWithTwoDisposables>(); Assert.AreEqual(obj1.Disposable, obj2.Disposable); Assert.AreEqual(obj1.Disposable, obj2.Disposable2); Assert.AreNotEqual(obj1, obj2); container.Teardown(obj1); Assert.IsFalse(obj1.Disposable.Disposed); container.Teardown(obj2); Assert.IsTrue(obj2.Disposable.Disposed); }
private void UnityAtRuntime() { // Create a new Unity container IUnityContainer UnityContainerObject = new UnityContainer(); Console.WriteLine("\nRetrieved the populated Unity Container."); // Resolve an instance (Create an object) of the class registered for ILogger. // And inejcts the object which specified in config file container section. ILogger ILoggerObject = UnityContainerObject.Resolve<MyLogger>(); // Invoke the method from Injected object and display the result Console.WriteLine("\n" + ILoggerObject.WriteMessage("My Logger")); UnityContainerObject.Teardown(ILoggerObject); // Register a new default (un-named) mapping with the container // This will replaces the existing mapping in the container for ILogger UnityContainerObject.RegisterType<ILogger, MyFastLogger>(); Console.WriteLine("\nRegistered a new mapping for IMyInterface to MyOtherObject."); ILoggerObject = UnityContainerObject.Resolve<ILogger>(); Console.WriteLine("\n" + ILoggerObject.WriteMessage("Fast Logger")); // Resolve an instance of the appropriate class registered for ILogger // Using the specified mapping name in the configuration file (may be empty for the default mapping) ILogger ILoggerInstance = UnityContainerObject.Resolve<ILogger>("StandardLogger"); // Get the logger to write a message and display the result Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO UNITY!")); // Resolve an instance of the appropriate class registered for ILogger // Using the specified mapping name (may be empty for the default mapping) ILoggerInstance = UnityContainerObject.Resolve<ILogger>("SuperFastLogger"); // This name specifies the type of logger required // Get the logger to write a message and display the result Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO UNITY!")); // Resolve an instance of the concrete MyObjectWithInjectedLogger class // This class contains a reference to ILogger in the constructor parameters MyObjectWithInjectedLogger MyObjectWithInjectedLoggerInstance = UnityContainerObject.Resolve<MyObjectWithInjectedLogger>(); // Get the injected logger to write a message and display the result Console.WriteLine("\n" + MyObjectWithInjectedLoggerInstance.GetObjectStringResult()); Console.ReadLine(); }
public void CreateNewAfterDispose_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingSharedLifetimeManager()); var obj1 = container.Resolve<DisposableClass>(); container.Teardown(obj1); Assert.IsTrue(obj1.Disposed, "After teardown of only instance, object should be disposed."); var obj2 = container.Resolve<DisposableClass>(); Assert.AreNotEqual(obj1, obj2, "Object was previously disposed, new instance should be created."); var obj3 = container.Resolve<DisposableClass>(); Assert.AreEqual(obj2, obj3, "Second reference to the same object expected."); }
public void ForgottenTeardown_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingSharedLifetimeManager()); var obj1 = container.Resolve<ClassWithDisposable>(); var obj2 = container.Resolve<ClassWithDisposable>(); var obj3 = container.Resolve<ClassWithDisposable>(); var wr = new WeakReference(obj1); obj1 = null; GC.Collect(); Assert.IsFalse(wr.IsAlive); container.Teardown(obj2); Assert.IsFalse(obj2.Disposable.Disposed); container.Teardown(obj3); Assert.IsTrue(obj2.Disposable.Disposed); }
public void TeardownParsleyAsCachedDisposesParsleyWhenCacheLifetimeStrategyExtensionIsAdded() { var container = new UnityContainer(); container.AddNewExtension<CacheLifetimeStrategyExtension>(); var lease = new SlidingLease(TimeSpan.FromTicks(1)); var cache = new CacheLifetimeManager(lease); container.RegisterType<IIngredient, Parsley>(cache); var ingredient = container.Resolve<IIngredient>(); Thread.Sleep(TimeSpan.FromMilliseconds(1)); container.Teardown(ingredient); var parsley = Assert.IsAssignableFrom<Parsley>(ingredient); Assert.True(parsley.IsDisposed); }
public void RegisteredAsDisposable_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingTransientLifetimeManager()); var obj1 = container.Resolve<DisposableClass>(); var obj2 = container.Resolve<DisposableClass>(); Assert.AreNotEqual(obj1, obj2); container.Teardown(obj1); Assert.IsTrue(obj1.Disposed); container.Teardown(obj2); Assert.IsTrue(obj2.Disposed); }
public void TeardownParsleyAsPerResolveDoesNotDisposeParsley() { var container = new UnityContainer(); container.RegisterType<IIngredient, Parsley>(new PerResolveLifetimeManager()); var ingredient = container.Resolve<IIngredient>(); container.Teardown(ingredient); var parsley = Assert.IsAssignableFrom<Parsley>(ingredient); Assert.False(parsley.IsDisposed); // <-- Boo hiss!! }
public void TeardownParsleyAsSingletonDoesNotDisposeParsley() { var container = new UnityContainer(); container.RegisterType<IIngredient, Parsley>(new ContainerControlledLifetimeManager()); var ingredient = container.Resolve<IIngredient>(); container.Teardown(ingredient); var parsley = Assert.IsAssignableFrom<Parsley>(ingredient); Assert.False(parsley.IsDisposed); }
public void MixedRegistrations_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingTransientLifetimeManager()); container.RegisterType<DisposableClass>("transient"); var disposingObj = container.Resolve<DisposableClass>(); var disposingObj2 = container.Resolve<DisposableClass>("disposing"); var transientObj = container.Resolve<DisposableClass>("transient"); Assert.AreNotEqual(disposingObj, disposingObj2); Assert.AreNotEqual(disposingObj, transientObj); container.Teardown(disposingObj); Assert.IsTrue(disposingObj.Disposed); container.Teardown(disposingObj2); Assert.IsTrue(disposingObj.Disposed); container.Teardown(transientObj); Assert.IsFalse(transientObj.Disposed); }
public void UnregisteredGenericParent_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); var obj1 = container.Resolve<GenericClass<SimpleClass>>(); var obj2 = container.Resolve<GenericClass<DisposableClass>>(); Assert.AreNotEqual(obj1, obj2); container.Teardown(obj1); container.Teardown(obj2); Assert.IsFalse(obj2.Property.Disposed); }
public void UnregisteredClass_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); var obj1 = container.Resolve<DisposableClass>(); var obj2 = container.Resolve<DisposableClass>(); Assert.AreNotEqual(obj1, obj2); container.Teardown(obj1); Assert.IsFalse(obj1.Disposed); container.Teardown(obj2); Assert.IsFalse(obj2.Disposed); }
public void TeardownParsleyAsCachedDoesNotDisposeParsley() { var container = new UnityContainer(); container.RegisterType<IIngredient, Parsley>(new CacheLifetimeManager(new SlidingLease(TimeSpan.FromMinutes(1)))); var ingredient = container.Resolve<IIngredient>(); container.Teardown(ingredient); var parsley = Assert.IsAssignableFrom<Parsley>(ingredient); Assert.False(parsley.IsDisposed); // <-- Boo hiss!! }
public void NonDisposable_Test() { using (var container = new UnityContainer()) { container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<SimpleClass>(new DisposingTransientLifetimeManager()); var obj1 = container.Resolve<SimpleClass>(); container.Teardown(obj1); } }