コード例 #1
0
        /// <summary>
        /// 注册生命周期
        /// </summary>
        /// <typeparam name="TLimit">TLimit</typeparam>
        /// <typeparam name="TActivatorData">TActivatorData</typeparam>
        /// <typeparam name="TRegistrationStyle">TRegistrationStyle</typeparam>
        /// <param name="registration"></param>
        /// <param name="scopes"></param>
        /// <returns></returns>
        private static IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> SetLifetimeScope <TLimit, TActivatorData, TRegistrationStyle>(
            IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> registration,
            LifetimeScopes scopes)
        {
            switch (scopes)
            {
            case LifetimeScopes.PerDependency:
            {
                registration = registration.InstancePerDependency();
                break;
            }

            case LifetimeScopes.PerLifetimeScope:
            {
                registration = registration.InstancePerLifetimeScope();
                break;
            }

            case LifetimeScopes.SingleInstance:
            {
                registration = registration.SingleInstance();
                break;
            }

            default:
                break;
            }

            return(registration);
        }
コード例 #2
0
        /// <summary>
        /// 注册实现为抽象
        /// </summary>
        /// <typeparam name="TImplementer">实现类型</typeparam>
        /// <param name="scopes">生命周期</param>
        /// <param name="abstractTypes">抽象类型</param>
        public static void RegisteTypeAsTypes <TImplementer>(
            LifetimeScopes scopes = LifetimeScopes.PerDependency,
            params Type[] abstractTypes)
        {
            var register = Builder.RegisterType <TImplementer>();

            if (abstractTypes.Length > 0)
            {
                register = register.As(abstractTypes);
            }

            SetLifetimeScope(register, scopes);
        }
コード例 #3
0
        /// <summary>
        /// 注册实现为抽象
        /// </summary>
        /// <typeparam name="TImplementer">实现类型</typeparam>
        /// <typeparam name="TAbstract">接口类型</typeparam>
        /// <param name="scopes">生命周期</param>
        /// <param name="name">名称</param>
        public static void RegisteTypeAsType <TImplementer, TAbstract>(
            LifetimeScopes scopes = LifetimeScopes.PerDependency,
            string name           = "")
        {
            var register = Builder.RegisterType <TImplementer>().AsSelf();

            if (string.IsNullOrEmpty(name))
            {
                register = register.As <TAbstract>();
            }
            else
            {
                register = register.Named <TAbstract>(name);
            }

            SetLifetimeScope(register, scopes);
        }
コード例 #4
0
        /// <summary>
        /// 注册泛型实现
        /// </summary>
        /// <param name="implemeterType"></param>
        /// <param name="abstractType"></param>
        /// <param name="scopes"></param>
        /// <param name="name"></param>
        public static void RegisterGenericAsType(
            Type implemeterType,
            Type abstractType,
            LifetimeScopes scopes,
            string name = "")
        {
            var register = Builder.RegisterGeneric(implemeterType);

            if (string.IsNullOrEmpty(name))
            {
                register = register.As(abstractType);
            }
            else
            {
                register = register.Named(name, abstractType);
            }

            SetLifetimeScope(register, scopes);
        }