private object CreateImplementation(ImplementationInfo implInfo)
{
Type ImplementationType = implInfo.ImplementationType;
if (implInfo.LifeTime == ImplementationLifeTime.Singleton && ImplementationInstances.ContainsKey(ImplementationType))
{
return(ImplementationInstances[ImplementationType]);
}
var CtorParams = new List <object>();
ConstructorInfo DesiredCtor = ImplementationType.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
foreach (ParameterInfo parameter in DesiredCtor.GetParameters())
{
CtorParams.Add(ResolveByType(parameter.ParameterType));
}
object ResultObject = Activator.CreateInstance(ImplementationType, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, CtorParams.ToArray(), null);
if (implInfo.LifeTime == ImplementationLifeTime.Singleton && !ImplementationInstances.ContainsKey(ImplementationType))
{
if (!ImplementationInstances.TryAdd(ImplementationType, ResultObject))
{
return(ImplementationInstances[ImplementationType]);
}
}
return(ResultObject);
}
private object GetInstance(ImplementationInfo implementation)
{
if (implementation.SingleTone)
{
return(implementation.SingleToneRealization.GetInstance(this));
}
return(Create(implementation.ImplementationType));
}
public void Register(Type dependency, Type implementation, bool singleTone = false)
{
ImplementationInfo implementationInfo = new ImplementationInfo(implementation, singleTone);
if (DependencesList.ContainsKey(implementation))
{
DependencesList[implementation].Add(implementationInfo);
}
else
{
DependencesList.TryAdd(dependency, new List <ImplementationInfo>());
DependencesList[dependency].Add(implementationInfo);
}
}
public void Register(Type DependencyType, Type ImplementationType, ImplementationLifeTime lifeTime = ImplementationLifeTime.InstancePerDependency)
{
if (!isDependencyValid(DependencyType, ImplementationType))
{
return;
}
ImplementationInfo implInfo = new ImplementationInfo(ImplementationType, lifeTime);
if (!config.ContainsKey(DependencyType))
{
config.Add(DependencyType, new List <ImplementationInfo> {
implInfo
});
}
else if (!config[DependencyType].Exists(obj => Equals(obj.ImplementationType, implInfo.ImplementationType)))
{
config[DependencyType].Add(implInfo);
}
}
private object ResolveByType(Type DependencyType)
{
// passing IEnumerable
if (typeof(IEnumerable).IsAssignableFrom(DependencyType))
{
Type RealDependencyType = DependencyType.GetGenericArguments()[0];
IList ResultObjectList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(RealDependencyType));
if (dependencies.config.ContainsKey(RealDependencyType))
{
foreach (var item in dependencies.config[RealDependencyType])
{
ResultObjectList.Add(CreateImplementation(item));
}
return(ResultObjectList);
}
else
{
return(null);
}
}
// open generic dependency
if (isGenericDependency(DependencyType))
{
Type GenericType = DependencyType.GetGenericTypeDefinition();
if (dependencies.config.ContainsKey(GenericType))
{
ImplementationInfo implInfo = dependencies.config[GenericType].First();
implInfo.ImplementationType = implInfo.ImplementationType.MakeGenericType(DependencyType.GetGenericArguments()[0]);
return(CreateImplementation(implInfo));
}
}
// simple or generic dependency
if (dependencies.config.ContainsKey(DependencyType))
{
return(CreateImplementation(dependencies.config[DependencyType].First()));
}
return(null);
}
