/// <summary>
 /// Initializes a new instance of the <see cref="DependencyLifetimeScopeEndingEventArgs"/> class.
 /// </summary>
 /// <param name="lifetimeScope">The lifetime scope that is ending.</param>
 public DependencyLifetimeScopeEndingEventArgs(IDependencyLifetimeScope lifetimeScope)
 {
     if (lifetimeScope == null)
     {
         throw new ArgumentNullException(nameof(lifetimeScope));
     }
     LifetimeScope = lifetimeScope;
 }
示例#2
0
        private TNextSequenceNumberRepository ResolveNextSequenceNumberRepository(IDependencyLifetimeScope scope)
        {
            var nextSequenceNumberRepository = (TNextSequenceNumberRepository)scope.Resolve(typeof(TNextSequenceNumberRepository));

            if (nextSequenceNumberRepository == null)
            {
                throw new InvalidOperationException($"Can't resolve {typeof(TNextSequenceNumberRepository).Name} from the dependency lifetime scope");
            }
            return(nextSequenceNumberRepository);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="DependencyResolvedEventArgs"/> class.
 /// </summary>
 /// <param name="lifetimeScope">The lifetime scope where the dependency was resolved.</param>
 /// <param name="dependencyType">The dependency type that was resolved.</param>
 /// <param name="dependency">The dependency instance that was resolved.</param>
 public DependencyResolvedEventArgs(IDependencyLifetimeScope lifetimeScope, Type dependencyType, object dependency)
 {
     if (lifetimeScope == null)
     {
         throw new ArgumentNullException(nameof(lifetimeScope));
     }
     if (dependencyType == null)
     {
         throw new ArgumentNullException(nameof(dependencyType));
     }
     if (dependency == null)
     {
         throw new ArgumentNullException(nameof(dependency));
     }
     LifetimeScope  = lifetimeScope;
     DependencyType = dependencyType;
     Dependency     = dependency;
 }
示例#4
0
        /// <summary>
        /// 依赖引擎初始化(再次初始化等于重新构造)
        /// </summary>
        public void Initialize()
        {
            #region 1.初始化固定系统级注册

            ContainerBuilder builder = new ContainerBuilder();
            builder.Register <ITypeFinder>(c => new TypeDefaultFinder()).SingleInstance();
            builder.Register <IDbMappingHandler>(c => new DbMappingHandler()).SingleInstance();

            //加密&解密
            this.CryptographyRegistration(builder);

            this._container = builder.Build();

            ITypeFinder typeFinder = this._container.Resolve <ITypeFinder>();
            if (null == typeFinder)
            {
                throw new Exception("typeFinder is not register!");
            }

            #endregion

            #region 2.IDependencyLifetimeScope引擎接口注册

            IEnumerable <Type> lifetimeScopeTypes = typeFinder.FindClassesOfType <IDependencyLifetimeScope>();
            int lifetimeScopeClassTotal           = lifetimeScopeTypes.Count(d => d.FullName != this.GetType().FullName);
            if (lifetimeScopeClassTotal <= 0)
            {
                this._lifetimeScop = this;
            }
            else
            {
                if (lifetimeScopeClassTotal > 1)
                {
                    throw new Exception("IDependencyLifetimeScope接口的实现只用在全局实现一次即可,切勿多次实现!");
                }

                this._lifetimeScop = Activator.CreateInstance(lifetimeScopeTypes.First()) as IDependencyLifetimeScope;
            }

            #endregion

            #region 3.IDependencyRegisterHook 外部挂钩注册

            IEnumerable <Type> hookTypes = typeFinder.FindClassesOfType <IDependencyRegisterHook>();
            if (hookTypes.Any())
            {
                builder = new ContainerBuilder();

                List <IDependencyRegisterHook> hookList = new List <IDependencyRegisterHook>();
                foreach (var hookT in hookTypes)
                {
                    hookList.Add(Activator.CreateInstance(hookT) as IDependencyRegisterHook);
                }
                hookList = hookList.AsQueryable().OrderBy(d => d.Priority).ToList();
                hookList.ForEach(o => o.Register(builder, typeFinder));

                builder.Update(this._container);
            }

            #endregion

            #region 99.挂载自身接口与实现的注册(单例)

            builder = new ContainerBuilder();
            builder.RegisterInstance(this).As(typeof(IDependencyManager), typeof(IDependencyResolver)).SingleInstance();
            builder.Update(this._container);

            #endregion

            #region 100.将注册的IDependencyRebuildDelegate接口实现进行纳入执行

            IEnumerable <Type>             rebuildDelegateTypes = typeFinder.FindClassesOfType <IDependencyInitComplete>();
            List <IDependencyInitComplete> taskList             = new List <IDependencyInitComplete>();
            foreach (var taskT in rebuildDelegateTypes)
            {
                taskList.Add(Activator.CreateInstance(taskT) as IDependencyInitComplete);
            }
            foreach (var taskOpt in taskList.AsQueryable().OrderBy(d => d.Priority))
            {
                taskOpt.OnCompleted(this._container);
            }

            #endregion
        }