Beispiel #1
0
 //Выбор действий в зависимости от Singleton или Instance
 private object GetObject(ImplementationInfo implInfo)
 {
     if (implInfo.lifeTime == LifeTime.Singleton)
     {
         if (!ImplementationInstances.ContainsKey(implInfo.ImplementationType))
         {
             var impl = CreateObject(implInfo.ImplementationType);
             ImplementationInstances.TryAdd(implInfo.ImplementationType, impl);
         }
         //Возврат значения из словаря
         return(ImplementationInstances[implInfo.ImplementationType]);
     }
     else
     {
         //Создание нового объекта
         return(CreateObject(implInfo.ImplementationType));
     }
 }
Beispiel #2
0
        public void Register(Type tDependency, Type tImplementation, LifeTime lifetime)
        {
            if (tDependency.IsValueType)
            {
                throw new ArgumentException("TDependency must be a reference type");
            }

            if (tImplementation.IsAbstract)
            {
                throw new ArgumentException("TImplementation can't be an abstract class");
            }

            if (!tImplementation.GetConstructors(BindingFlags.Public | BindingFlags.Instance).Any())
            {
                throw new ArgumentException("TImplementation doesn't have any public constructors");
            }

            if (!tDependency.IsAssignableFrom(tImplementation) && !tDependency.IsGenericTypeDefinition)
            {
                throw new ArgumentException("TImplementation doesn't implement TDependency interface");
            }


            //Если в словаре нет такого интерфейса, создаем запись и список
            if (!RegisteredDependencies.ContainsKey(tDependency))
            {
                RegisteredDependencies.Add(tDependency, new List <ImplementationInfo>());
            }

            if (RegisteredDependencies[tDependency].Find(item => item.ImplementationType == tImplementation) != null)
            {
                throw new ArgumentException("Such dependency is already registered");
            }

            else
            {
                ImplementationInfo impl = new ImplementationInfo(tImplementation, lifetime);
                RegisteredDependencies[tDependency].Add(impl);
            }
        }
Beispiel #3
0
        public object Resolve(Type DependencyType)
        {
            object resultObj = null;

            // Если в стеке уже встречался обьект с таким типом, то
            // объект получает значение по умолчанию (0 или null)
            if (!cycleStack.Contains(DependencyType))
            {
                cycleStack.Push(DependencyType);
                List <ImplementationInfo> implInfos;


                // 1.IEnumerable<IService> services = provider.Resolve<IEnumerable<IService>>();
                if (typeof(IEnumerable).IsAssignableFrom(DependencyType))
                {
                    Type actualDependency = DependencyType.GetGenericArguments()[0];
                    if (dependencyConfig.RegisteredDependencies.ContainsKey(actualDependency))
                    {
                        implInfos = dependencyConfig.RegisteredDependencies[actualDependency];
                        int implCount = implInfos.Count;
                        var array     = Array.CreateInstance(actualDependency, implCount);

                        for (int i = 0; i < implCount; i++)
                        {
                            array.SetValue(GetObject(implInfos[i]), i);
                        }

                        cycleStack.Pop();
                        return(array);
                    }
                    else
                    {
                        throw new KeyNotFoundException($"Dependency {actualDependency.Name} is not registered.");
                    }
                }

                // 2.Open generic dependency
                //Если это дженерик и имплементация IService<> есть в словаре
                if (DependencyType.IsGenericType && dependencyConfig.RegisteredDependencies.ContainsKey(DependencyType.GetGenericTypeDefinition()))
                {
                    //Получаем из IService<IRepos>  -> IService'
                    Type GenericType = DependencyType.GetGenericTypeDefinition();

                    //Вытягиваем реализацию ServiceImpl
                    ImplementationInfo implInfo = dependencyConfig.RegisteredDependencies[GenericType].First();

                    //ServiceImpl<>  -> ServiceImpl<IRepos>
                    implInfo.ImplementationType = implInfo.ImplementationType.MakeGenericType(DependencyType.GetGenericArguments()[0]);

                    object result = GetObject(implInfo);
                    cycleStack.Pop();

                    return(result);
                }


                // 3.Simple Generic Dependency or SimpleDependency
                if (dependencyConfig.RegisteredDependencies.ContainsKey(DependencyType))
                {
                    implInfos = dependencyConfig.RegisteredDependencies[DependencyType];

                    object result = GetObject(implInfos.First());
                    cycleStack.Pop();

                    return(result);
                }
                else if (!dependencyConfig.RegisteredDependencies.ContainsKey(DependencyType))
                {
                    throw new KeyNotFoundException($"Dependency {DependencyType.Name} is not registered.");
                }
            }
            else
            {
                return(GetDefaultValue(DependencyType));
            }

            return(resultObj);
        }