/// <summary>
        /// 枚举当前以及父级构建器依赖字典集合。
        /// </summary>
        /// <param name="currentDependency">给定的当前 <see cref="IExtensionBuilderDependency"/>。</param>
        /// <param name="excludeCurrentDependency">排除当前 <see cref="IExtensionBuilderDependency"/>(可选;默认不排除)。</param>
        /// <returns>返回字典集合。</returns>
        public static Dictionary <string, IExtensionBuilderDependency> EnumerateDependencies
            (this IExtensionBuilderDependency currentDependency, bool excludeCurrentDependency = false)
        {
            var dependencies = new Dictionary <string, IExtensionBuilderDependency>();

            LookupDependency(excludeCurrentDependency
                ? currentDependency?.ParentDependency
                : currentDependency);

            return(dependencies);

            // LookupDependency
            void LookupDependency(IExtensionBuilderDependency dependency)
            {
                if (dependency.IsNull())
                {
                    return;
                }

                dependencies.Add(dependency.Name, dependency);

                // 链式查找父级构建器依赖
                LookupDependency(dependency.ParentDependency);
            }
        }
        /// <summary>
        /// 尝试获取指定构建器依赖类型的实例(支持查找当前或父级实例)。
        /// </summary>
        /// <typeparam name="TDependency">指定的构建器类型。</typeparam>
        /// <param name="currentDependency">给定的当前 <see cref="IExtensionBuilderDependency"/>。</param>
        /// <param name="resultDependency">输出结果 <see cref="IExtensionBuilderDependency"/>。</param>
        /// <param name="excludeCurrentDependency">排除当前 <see cref="IExtensionBuilderDependency"/>(可选;默认不排除)。</param>
        /// <returns>返回是否成功获取的布尔值。</returns>
        public static bool TryGetDependency <TDependency>(this IExtensionBuilderDependency currentDependency,
                                                          out TDependency resultDependency, bool excludeCurrentDependency = false)
            where TDependency : class, IExtensionBuilderDependency
        {
            resultDependency = LookupDependency(excludeCurrentDependency
                ? currentDependency?.ParentDependency
                : currentDependency);

            return(resultDependency.IsNotNull());

            // LookupDependency
            TDependency LookupDependency(IExtensionBuilderDependency builderDependency)
            {
                if (builderDependency.IsNull())
                {
                    return(null);
                }

                if (builderDependency is TDependency dependency)
                {
                    return(dependency);
                }

                return(LookupDependency(builderDependency.ParentDependency));
            }
        }
コード例 #3
0
        protected AbstractExtensionBuilderDependency(string name, IExtensionBuilderDependency parentDependency = null)
            : base(name)
        {
            if (parentDependency.IsNotNull())
            {
                BaseDirectory     = parentDependency.BaseDirectory;
                ConfigDirectory   = parentDependency.ConfigDirectory;
                ReportDirectory   = parentDependency.ReportDirectory;
                ResourceDirectory = parentDependency.ResourceDirectory;

                ConfigurationRoot = parentDependency.ConfigurationRoot;

                if (ConfigurationRoot.IsNotNull())
                {
                    Configuration = ConfigurationRoot.GetSection(Name);
                }

                ParentDependency = parentDependency;
            }
            else
            {
                var currentDirectory = Environment.CurrentDirectory.WithoutDevelopmentRelativePath();

                BaseDirectory     = currentDirectory;
                ConfigDirectory   = currentDirectory.CombinePath(CoreSettings.Preference.ConfigsFolder);
                ReportDirectory   = currentDirectory.CombinePath(CoreSettings.Preference.ReportsFolder);
                ResourceDirectory = currentDirectory.CombinePath(CoreSettings.Preference.ResourcesFolder);
            }
        }
コード例 #4
0
        protected AbstractExtensionBuilder(IExtensionBuilder parentBuilder, IExtensionBuilderDependency dependency)
        {
            Dependency    = dependency.NotNull(nameof(dependency));
            ParentBuilder = parentBuilder.NotNull(nameof(parentBuilder));

            Services = parentBuilder.Services;
        }
        /// <summary>
        /// 获取必需的构建器依赖实例(支持查找当前或父级实例)。
        /// </summary>
        /// <typeparam name="TDependency">指定的构建器依赖类型。</typeparam>
        /// <param name="currentDependency">给定的当前 <see cref="IExtensionBuilderDependency"/>。</param>
        /// <param name="excludeCurrentDependency">排除当前 <see cref="IExtensionBuilderDependency"/>(可选;默认不排除)。</param>
        /// <returns>返回 <typeparamref name="TDependency"/> 或抛出 <see cref="InvalidOperationException"/>。</returns>
        public static TDependency GetRequiredDependency <TDependency>
            (this IExtensionBuilderDependency currentDependency, bool excludeCurrentDependency = false)
            where TDependency : class, IExtensionBuilderDependency
        {
            if (!currentDependency.TryGetDependency <TDependency>(out var resultDependency, excludeCurrentDependency))
            {
                throw new InvalidOperationException($"The current dependency is not or does not contain a parent dependency '{typeof(TDependency)}'.");
            }

            return(resultDependency);
        }
コード例 #6
0
        /// <summary>
        /// 构造一个 <see cref="DataBuilderDependency"/>。
        /// </summary>
        /// <param name="name">给定的名称。</param>
        /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
        protected DataBuilderDependency(string name, IExtensionBuilderDependency parentDependency = null)
            : base(name, parentDependency)
        {
            // ConfigDirectory
            //CompilersConfigDirectory = ConfigDirectory.CombinePath(DataSettings.Preference.CompilersFolder);
            DatabasesConfigDierctory  = ConfigDirectory.CombinePath(DataSettings.Preference.DatabasesFolder);
            MigrationsConfigDirectory = ConfigDirectory.CombinePath(DataSettings.Preference.MigrationsFolder);

            // ReportDirectory
            DatabasesReportDirectory    = ReportDirectory.CombinePath(DataSettings.Preference.DatabasesFolder);
            InitializersReportDirectory = ReportDirectory.CombinePath(DataSettings.Preference.InitializersFolder);
        }
コード例 #7
0
        public static bool TryAddReferenceBuilderDependency <TTargetDependency>(this IServiceCollection services,
                                                                                IExtensionBuilderDependency dependency, Type dependencyType = null)
            where TTargetDependency : class, IExtensionBuilderDependency
        {
            services.NotNull(nameof(services));
            dependency.NotNull(nameof(dependency));

            if (dependencyType.IsNull())
            {
                dependencyType = dependency.GetType();
            }

            var referenceType = typeof(TTargetDependency);

            if (referenceType != dependencyType)
            {
                services.AddSingleton(referenceType, sp => sp.GetRequiredService(dependencyType));
                return(true);
            }

            return(false);
        }
コード例 #8
0
 /// <summary>
 /// 构造一个 <see cref="StorageBuilderDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public StorageBuilderDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(StorageBuilderDependency), parentDependency)
 {
 }
コード例 #9
0
 /// <summary>
 /// 构造一个 <see cref="PortalBuilderDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public PortalBuilderDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(PortalBuilderDependency), parentDependency)
 {
 }
 /// <summary>
 /// 包含指定构建器依赖类型的实例(支持查找当前或父级实例)。
 /// </summary>
 /// <typeparam name="TDependency">指定的构建器类型。</typeparam>
 /// <param name="currentDependency">给定的当前 <see cref="IExtensionBuilderDependency"/>。</param>
 /// <param name="excludeCurrentDependency">排除当前 <see cref="IExtensionBuilderDependency"/>(可选;默认不排除)。</param>
 /// <returns>返回是否成功获取的布尔值。</returns>
 public static bool ContainsDependency <TDependency>(this IExtensionBuilderDependency currentDependency,
                                                     bool excludeCurrentDependency = false)
     where TDependency : class, IExtensionBuilderDependency
 => currentDependency.TryGetDependency <TDependency>(out _, excludeCurrentDependency);
コード例 #11
0
 /// <summary>
 /// 构造一个 <see cref="DrawingBuilderDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public DrawingBuilderDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(DrawingBuilderDependency), parentDependency)
 {
 }
コード例 #12
0
 public InternalBuilder(IServiceCollection services, IExtensionBuilderDependency dependency)
     : base(services, dependency)
 {
     Services.AddSingleton(this);
 }
コード例 #13
0
 /// <summary>
 /// 构造一个 <see cref="EncryptionBuilderDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public EncryptionBuilderDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(EncryptionBuilderDependency), parentDependency)
 {
 }
コード例 #14
0
 /// <summary>
 /// 构造一个 <see cref="NetworkBuilderDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public NetworkBuilderDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(NetworkBuilderDependency), parentDependency)
 {
 }
コード例 #15
0
 /// <summary>
 /// 构造一个 <see cref="AbstractExtensionBuilderDecorator{TSource}"/>。
 /// </summary>
 /// <param name="source">给定的装饰 <typeparamref name="TSource"/>。</param>
 /// <param name="parentBuilder">给定的父级 <see cref="IExtensionBuilder"/>。</param>
 /// <param name="dependency">给定的 <see cref="IExtensionBuilderDependency"/>。</param>
 protected AbstractExtensionBuilderDecorator(TSource source,
                                             IExtensionBuilder parentBuilder, IExtensionBuilderDependency dependency)
     : base(parentBuilder, dependency)
 {
     Source = source.NotNull(nameof(source));
 }
コード例 #16
0
 /// <summary>
 /// 构造一个 <see cref="ContentBuilderDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public ContentBuilderDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(ContentBuilderDependency), parentDependency)
 {
 }
コード例 #17
0
 public PublicBuilderDependency(IExtensionBuilderDependency parentDependency)
     : base(nameof(PublicBuilderDependency), parentDependency)
 {
 }
コード例 #18
0
 public PublicBuilder(IExtensionBuilder parentBuilder, IExtensionBuilderDependency dependency)
     : base(parentBuilder, dependency)
 {
     Services.AddSingleton(this);
 }
コード例 #19
0
 /// <summary>
 /// 构造一个 <see cref="AbstractExtensionBuilderDecorator{TSource}"/>。
 /// </summary>
 /// <param name="source">给定的装饰 <typeparamref name="TSource"/>。</param>
 /// <param name="services">给定的 <see cref="IServiceCollection"/>。</param>
 /// <param name="dependency">给定的 <see cref="IExtensionBuilderDependency"/>。</param>
 protected AbstractExtensionBuilderDecorator(TSource source,
                                             IServiceCollection services, IExtensionBuilderDependency dependency)
     : base(services, dependency)
 {
     Source = source.NotNull(nameof(source));
 }
コード例 #20
0
 /// <summary>
 /// 构造一个 <see cref="AbstractExtensionBuilder"/>。
 /// </summary>
 /// <param name="services">给定的 <see cref="IServiceCollection"/>。</param>
 /// <param name="dependency">给定的 <see cref="IExtensionBuilderDependency"/>。</param>
 protected AbstractExtensionBuilder(IServiceCollection services, IExtensionBuilderDependency dependency)
 {
     Dependency = dependency.NotNull(nameof(dependency));
     Services   = services.NotNull(nameof(services));
 }
コード例 #21
0
 /// <summary>
 /// 构造一个 <see cref="NetworkBuilderDependency"/>。
 /// </summary>
 /// <param name="name">给定的名称。</param>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 protected NetworkBuilderDependency(string name, IExtensionBuilderDependency parentDependency = null)
     : base(name, parentDependency)
 {
 }
コード例 #22
0
 /// <summary>
 /// 构造一个 <see cref="DotNettyDependency"/>。
 /// </summary>
 /// <param name="parentDependency">给定的父级 <see cref="IExtensionBuilderDependency"/>(可选)。</param>
 public DotNettyDependency(IExtensionBuilderDependency parentDependency = null)
     : this(nameof(DotNettyDependency), parentDependency)
 {
 }