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