public bool TryGet(Type requiredType, out IDependencyDefinition definition)
{
Ensure.NotNull(requiredType, "requiredType");
DependencyDefinition result;
if (definitionByRequiredType.TryGetValue(requiredType, out result))
{
definition = result.Clone(isResolvable(requiredType));
return(true);
}
if (parentCollection != null)
{
if (parentCollection.TryGet(requiredType, out definition))
{
if (!definition.IsResolvable && isResolvable(requiredType))
{
definition = new DependencyDefinition(definition.RequiredType, definition.Lifetime, definition.Target, true);
}
return(true);
}
}
definition = null;
return(false);
}
private void FillDependencyProperties(DependencyDefinition definition, object instance)
{
foreach (PropertyInfo propertyInfo in definition.DependencyProperties)
{
propertyInfo.SetValue(instance, Resolve(propertyInfo.PropertyType));
}
}
internal bool TryGetInternal(Type requiredType, out DependencyDefinition definition)
{
string key = requiredType.FullName;
if (definitionByKey.TryGetValue(key, out definition))
{
definition = definition.Clone(true);
return(true);
}
foreach (List <DependencyDefinition> items in definitionByScopeName.Values)
{
foreach (DependencyDefinition item in items)
{
if (item.RequiredType == requiredType)
{
definition = item.Clone(false);
return(true);
}
}
}
if (parentCollection != null)
{
if (parentCollection.TryGetInternal(requiredType, out definition))
{
return(true);
}
}
definition = null;
return(false);
}
private void AddDefinitionToScope(string scopeName, DependencyDefinition definition)
{
List <DependencyDefinition> list;
if (!definitionByScopeName.TryGetValue(scopeName, out list))
{
definitionByScopeName[scopeName] = list = new List <DependencyDefinition>();
}
list.Add(definition);
}
/// <summary>
/// Tries to find dependency properties on implementation type.
/// </summary>
/// <param name="definition">Dependency definition.</param>
private void FindDependencyProperties(DependencyDefinition definition)
{
Type targetType = definition.Target as Type;
if (targetType == null)
{
return;
}
foreach (PropertyInfo property in targetType.GetProperties())
{
if (property.GetCustomAttributes(typeof(DependencyAttribute)).Any())
{
definition.DependencyProperties.Add(property);
}
}
}
/// <summary>
/// Adds definition, if <paramref name="definition"/> is for current scope, registers it the unity container.
/// Otherwise stores <paramref name="definition"/> in current mapping collection to any child scopes.
/// </summary>
/// <param name="definition">New dependency definition.</param>
/// <returns>Self (for fluency).</returns>
public Mapper Add(DependencyDefinition definition)
{
// If lifetime is current scope, register to the unity container.
if (!definition.Lifetime.IsNamed || definition.Lifetime.Name == scopeName)
{
LifetimeManager lifetimeManager = CreateLifetimeManager(definition.Lifetime, definition.Target is Type);
Register(definition.RequiredType, lifetimeManager, definition.Target);
}
// If lifetime is not transient, store for child scopes.
if (definition.Lifetime.IsNamed)
{
collection.Add(definition);
}
return(this);
}
private object Build(DependencyDefinition definition)
{
// For transient definition, create new instance (always).
if (definition.Lifetime.IsTransient)
{
return(CreateNewInstanceFromDefinition(definition));
}
// For scoped definition, try get instance or create new one.
object instance = instances.TryGetObject(definition.Key);
if (instance == null)
{
instance = CreateNewInstanceFromDefinition(definition);
instances.AddObject(definition.Key, instance);
}
return(instance);
}
private void AddDefinition(DependencyDefinition definition)
{
// If definition is usable for current scope, add it to the definitionByKey.
if (definition.Lifetime.IsTransient || (definition.Lifetime.IsScoped && (definition.Lifetime.IsNamed && definition.Lifetime.Name == ScopeName) || !definition.Lifetime.IsNamed))
{
definitionByKey[definition.Key] = definition;
}
if (definition.Lifetime.IsNamed)
{
// If definition is targeted for other scope, add it to the definitionByScopeName.
AddDefinitionToScope(definition.Lifetime.Name, definition);
}
else if (definition.Lifetime.IsScoped)
{
// If definition is targeted to any scope, add it to the definitionByScopeName with empty scope name.
AddDefinitionToScope(String.Empty, definition);
}
}
public DependencyDefinition Clone(bool isResolvable)
{
DependencyDefinition result;
if (HasConstructorInfo)
{
result = new DependencyDefinition(RequiredType, Lifetime, Target, ConstructorInfo);
}
else
{
result = new DependencyDefinition(RequiredType, Lifetime, Target);
}
if (DependencyProperties.Count > 0)
{
result.DependencyProperties.AddRange(DependencyProperties);
}
result.IsResolvable = isResolvable;
return(result);
}
private object CreateNewInstanceFromDefinition(DependencyDefinition definition)
{
// When mapped to the implementation type or itself (type).
if (definition.HasConstructorInfo)
{
object instance = CreateInstance(definition.ConstructorInfo);
FillDependencyProperties(definition, instance);
return(instance);
}
// When mapped to the instance of activator.
IFactory <object> activator = instances.TryGetFactory(definition.Key);
if (activator != null)
{
return(activator.Create());
}
// When mapped to the type of activator.
//TODO: Implement.
throw new NotImplementedException();
}
/// <summary>
/// Adds NAME SCOPED dependency definition.
/// </summary>
/// <param name="definition">NAME SCOPED definition to add.</param>
/// <returns>Self (for fluency).</returns>
/// <exception cref="InvalidOperationException">If <paramref name="definition"/> is not scoped.</exception>
internal MapperCollection Add(DependencyDefinition definition)
{
string scopeName;
if (definition.Lifetime.IsNamed)
{
scopeName = definition.Lifetime.Name;
}
else
{
throw Ensure.Exception.InvalidOperation("MappingCollection supports only scoped or name-scoped registrations.");
}
List <DependencyDefinition> models;
if (!storage.TryGetValue(scopeName, out models))
{
storage[scopeName] = models = new List <DependencyDefinition>();
}
models.Add(definition);
return(this);
}
public IDependencyDefinitionCollection Add(Type requiredType, DependencyLifetime lifetime, object target)
{
mapper.Add(definitionByRequiredType[requiredType] = new DependencyDefinition(requiredType, lifetime, target));
return(this);
}
//TODO: Implement using registered features...
public IDependencyDefinitionCollection Add(Type requiredType, DependencyLifetime lifetime, object target)
{
Ensure.NotNull(requiredType, "requiredType");
Ensure.NotNull(target, "target");
// Target is type to map to.
Type targetType = target as Type;
if (targetType != null)
{
if (targetType.IsInterface)
{
throw new DependencyRegistrationFailedException(String.Format("Target can't be interface. Mapping '{0}' to '{1}'.", requiredType.FullName, targetType.FullName));
}
if (targetType.IsAbstract)
{
throw new DependencyRegistrationFailedException(String.Format("Target can't be abstract class. Mapping '{0}' to '{1}'.", requiredType.FullName, targetType.FullName));
}
ConstructorInfo constructorInfo = FindBestConstructor(targetType);
if (constructorInfo == null)
{
throw new DependencyRegistrationFailedException(String.Format("Target must has public contructor. Mapping '{0}' to '{1}'.", requiredType.FullName, targetType.FullName));
}
DependencyDefinition definition = new DependencyDefinition(
requiredType,
lifetime,
targetType,
constructorInfo
);
FindDependencyProperties(definition);
AddDefinition(definition);
return(this);
}
// Target is activator.
IFactory <object> targetActivator = target as IFactory <object>;
if (targetActivator != null)
{
DependencyDefinition definition = new DependencyDefinition(
requiredType,
lifetime,
targetActivator
);
instances.AddFactory(definition.Key, targetActivator);
AddDefinition(definition);
return(this);
}
// Target is instance of required type.
targetType = target.GetType();
if (requiredType.IsAssignableFrom(targetType))
{
DependencyDefinition definition = new DependencyDefinition(
requiredType,
lifetime,
target
);
instances.AddObject(definition.Key, target);
AddDefinition(definition);
return(this);
}
// Nothing else is supported.
throw Ensure.Exception.InvalidOperation("Not supported target type '{0}'.", target.GetType().FullName);
}
