/// <summary> /// Registers the type. /// </summary> /// <param name="serviceType">Type of the service.</param> /// <param name="implementationType">Type of the implementation.</param> /// <param name="lifetime">The lifetime of the service.</param> /// <returns></returns> public override IServiceRegistrar RegisterType(Type serviceType, Type implementationType, LifetimeType lifetime) { Invariant.IsNotNull(serviceType, "serviceType"); Invariant.IsNotNull(implementationType, "implementationType"); LifetimeManager lifeTimeManager; switch (lifetime) { case LifetimeType.PerRequest: lifeTimeManager = new PerRequestLifetimeManager(); break; case LifetimeType.Singleton: lifeTimeManager = new ContainerControlledLifetimeManager(); break; default: lifeTimeManager = new TransientLifetimeManager(); break; } if (Container.Registrations.Any(registration => registration.RegisteredType.Equals(serviceType))) { Container.RegisterType(serviceType, implementationType, implementationType.FullName, lifeTimeManager); } else { Container.RegisterType(serviceType, implementationType, lifeTimeManager); } return(this); }
/// <summary> /// Register the type mapping with the container, with the given <see cref="LifetimeType" />. /// </summary> /// <param name="serviceType"><see cref="System.Type" /> of the service that will be requested.</param> /// <param name="implementationType"><see cref="System.Type" /> of the implementation that will be returned.</param> /// <param name="lifetime">The <see cref="LifetimeType" /> of the service.</param> /// <returns>The <see cref="IContainerProvider" /> object that this method was called on.</returns> /// <exception cref="ArgumentException">Thrown when the implementation type does not inherit from IPerRequestTask and lifetime is PerRequest.</exception> public override IContainerProvider RegisterType(Type serviceType, Type implementationType, LifetimeType lifetime) { LifetimeManager lifetimeManager; switch (lifetime) { case LifetimeType.Singleton: lifetimeManager = new ContainerControlledLifetimeManager(); break; default: lifetimeManager = new TransientLifetimeManager(); break; } if (container.Registrations.Any(registration => registration.RegisteredType == serviceType)) { container.RegisterType(serviceType, implementationType, implementationType.FullName, lifetimeManager); } else { container.RegisterType(serviceType, implementationType, lifetimeManager); } return(this); }
/// <summary> /// Registers the type mapping. /// </summary> /// <param name="serviceType"><see cref="Type"/> that will be requested.</param> /// <param name="implementationType"><see cref="Type"/> that will actually be returned.</param> /// <param name="serviceName">Name to use for registration, null if a default registration.</param> /// <param name="lifetime">The lifetime strategy of the resolved instances.</param> protected override void DoRegister(Type serviceType, Type implementationType, string serviceName, ServiceLifetime lifetime) { if (_container == null) { throw new ObjectDisposedException("container"); } var args = new UnityServiceRegisterEventArgs(serviceType, implementationType, serviceName, lifetime); args.InjectionMembers.AddRange(_injectionMembers); OnRegistering(args); LifetimeManager lifetimeManager; switch (lifetime) { case ServiceLifetime.Transient: lifetimeManager = new TransientLifetimeManager(); break; case ServiceLifetime.PerThread: lifetimeManager = new PerThreadLifetimeManager(); break; case ServiceLifetime.PerRequest: lifetimeManager = new PerRequestLifetimeManager(); break; default: lifetimeManager = new ContainerControlledLifetimeManager(); break; } _container.RegisterType(serviceType, implementationType, serviceName, lifetimeManager, args.InjectionMembers.ToArray()); }
public void TestAddRetrieve() { TransientLifetimeManager manager = new TransientLifetimeManager(); Mock<IDisposable> disposable = new Mock<IDisposable>(); manager.AddInstance(disposable.Object); Assert.IsNull(manager.GetInstance()); }
/// <summary> /// Convert the lifetime enum to a lifetime manager in Unity. /// </summary> /// <param name="type"> Type to register </param> /// <param name="lifetime"> Lifetime to convert </param> /// <returns> A lifetime manager </returns> protected virtual LifetimeManager GetLifetimeManager(Type type, Lifetime lifetime) { if (type == null) { throw new ArgumentNullException("type"); } LifetimeManager lifetimeManager; switch (lifetime) { case Lifetime.Transient: lifetimeManager = new TransientLifetimeManager(); break; case Lifetime.Singleton: lifetimeManager = new ContainerControlledLifetimeManager(); break; case Lifetime.Scoped: lifetimeManager = ScopedLifetimeFactory.Current.Create(); break; default: throw new InvalidOperationException( string.Format( "Either the [Component] attribute on {0} or the ComponentRegistrar.DefaultLifetime must have been specified.", type.FullName)); } return(lifetimeManager); }
public void TestDispose() { TransientLifetimeManager manager = new TransientLifetimeManager(); Mock<IDisposable> disposable = new Mock<IDisposable>(); manager.AddInstance(disposable.Object); manager.Dispose(); disposable.Verify(p => p.Dispose(), Times.Never()); }
public void TestRemoveInstance() { TransientLifetimeManager manager = new TransientLifetimeManager(); Mock<IDisposable> disposable = new Mock<IDisposable>(); manager.AddInstance(disposable.Object); manager.RemoveInstance(); disposable.Verify(p => p.Dispose(), Times.Never()); Assert.IsNull(manager.GetInstance()); }
public static void RegisterTransient(this IContainer container, Type fromType, Type toType, string key = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } var lifetimeManager = new TransientLifetimeManager(toType); container.Register(lifetimeManager, fromType, key); }
public void TransientNewObject() { var moqBuilder = new Mock <IObjectConstructor>(); moqBuilder.Setup(t => t.Build(It.IsAny <BuildDetails>())).Returns(() => new SimpleClass()); var manager = new TransientLifetimeManager(moqBuilder.Object); var obj1 = manager.CreateType(new RegistrationDetails()); var obj2 = manager.CreateType(new RegistrationDetails()); Assert.NotEqual(obj1, obj2); }
private LifetimeManager GetLifetimeManager(DependencyLifecycle lifecycle) { LifetimeManager manager = new ContainerControlledLifetimeManager(); switch (lifecycle) { case DependencyLifecycle.Transient: manager = new TransientLifetimeManager(); break; default: break; } return(manager); }
static void TestTransientLifetime_Nested() { Console.WriteLine("Test TransientLifetimeManager_Nested"); LifetimeTest.ResetCounter(); using (var container = new UnityContainer()) { var lifeManager = new TransientLifetimeManager(); container.RegisterType <ILifetimeTest, LifetimeTest>(lifeManager); var obj1 = container.Resolve <Foo>(); LifetimeTest.PrintCounter(); } LifetimeTest.PrintCounter(); }
/// <summary> /// Adds class to the container using Static container approach. /// </summary> /// <param name="name">alias name to use in type registration</param> /// <typeparam name="TTYpe">Marker interface for class isntance.</typeparam> /// <typeparam name="TInstance">Class implenting the <see cref="TTYpe"/>.</typeparam> public static void Add <TTYpe, TInstance>(string name, bool createNewEveryTime = false) where TInstance : class, TTYpe { LifetimeManager lifetimeManager; if (createNewEveryTime) { lifetimeManager = new TransientLifetimeManager(); } else { lifetimeManager = new ContainerControlledLifetimeManager(); } Current.RegisterType <TTYpe, TInstance>(name, lifetimeManager); }
public void RegisterType_T_Name_Manager() { // Arrange var manager = new TransientLifetimeManager(); // Act Container.RegisterType <Service>(Name, manager, new InjectionConstructor()); // Validate var registration = Container.Registrations.First(r => typeof(Service) == r.RegisteredType); Assert.AreEqual(typeof(Service), registration.RegisteredType); Assert.AreEqual(typeof(Service), registration.MappedToType); Assert.AreEqual(Name, registration.Name); Assert.AreSame(manager, registration.LifetimeManager); }
private static ILifetimePolicy GetLifetimePolicy(IBuilderContext context) { ILifetimePolicy policy = context.Policies.GetNoDefault <ILifetimePolicy>(context.BuildKey, false); if (policy == null && context.BuildKey.Type.IsGenericType) { policy = GetLifetimePolicyForGenericType(context); } if (policy == null) { policy = new TransientLifetimeManager(); context.PersistentPolicies.Set <ILifetimePolicy>(policy, context.BuildKey); } return(policy); }
public void RegisterFactrory_C_T_Name_Manager() { // Arrange var manager = new TransientLifetimeManager(); // Act Container.RegisterFactory <IService>(Name, ShortFactory, manager); // Validate var registration = Container.Registrations.First(r => typeof(IService) == r.RegisteredType); Assert.AreEqual(typeof(IService), registration.RegisteredType); Assert.AreEqual(typeof(IService), registration.MappedToType); Assert.AreEqual(Name, registration.Name); Assert.AreSame(manager, registration.LifetimeManager); }
public static void RegisterTransient(this IContainer container, Type type, string key = null, Func <IResolver, object> factory = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (factory == null) { container.RegisterTransient(type, type, key); return; } var lifetimeManager = new TransientLifetimeManager(type, factory); container.Register(lifetimeManager, type, key); }
private static LifetimeManager CreateLifeTime(LifeCycle lifeCycle) { LifetimeManager lifetimeManager = null; switch (lifeCycle) { case LifeCycle.Singleton: default: lifetimeManager = new SingletonLifetimeManager(); break; case LifeCycle.Transient: lifetimeManager = new TransientLifetimeManager(); break; } return(lifetimeManager); }
/* * Ok, this method is reaaly ugly. Luckily it is also realy low level * so it doesn't affect other parts that much. I don't know how it should be done properly. */ private void AutoRegisterClasses() { var defaultRegisters = AllClasses.FromLoadedAssemblies().Where(t => t.IsDefined(typeof(AutoRegisterAttribute), true)); HashSet <Type> alreadyInitialized = new HashSet <Type>(); foreach (var register in defaultRegisters) { if (register.IsAbstract) { continue; } var singleton = register.IsDefined(typeof(SingleInstanceAttribute), false); foreach (var interface_ in register.GetInterfaces()) { string name = null; if (alreadyInitialized.Contains(interface_)) { name = register.ToString() + interface_.ToString(); } else { alreadyInitialized.Add(interface_); } LifetimeManager life = null; if (singleton) { life = new ContainerControlledLifetimeManager(); } else { life = new TransientLifetimeManager(); } Container.GetContainer().RegisterType(interface_, register, name, life); } } }
private static LifetimeManager GetLifetimeManager(Lifetime lifetime) { LifetimeManager manager = null; switch (lifetime) { case Lifetime.Transient: manager = new TransientLifetimeManager(); break; case Lifetime.Singleton: manager = new ContainerControlledLifetimeManager(); break; case Lifetime.Thread: manager = new PerThreadLifetimeManager(); break; } return(manager); }
public void TestLifetimeManagerRegisterResolve() { var lifetimeManager = new TransientLifetimeManager(typeof(SimpleDependency)); bool keepTrackObject; var resolvedObject1 = lifetimeManager.Resolve(null, out keepTrackObject); Assert.IsNotNull(resolvedObject1); Assert.IsInstanceOfType(resolvedObject1, typeof(SimpleDependency)); var resolvedObject2 = lifetimeManager.Resolve(null, out keepTrackObject); Assert.IsNotNull(resolvedObject2); Assert.IsInstanceOfType(resolvedObject2, typeof(SimpleDependency)); Assert.AreNotSame(resolvedObject1, resolvedObject2); Assert.AreEqual(SimpleDependency.ActiveDependecies, 2); ((IDisposable)resolvedObject1).Dispose(); ((IDisposable)resolvedObject2).Dispose(); }