/// <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();
}
