七色花基本权限系统（9）- 中途整理和完善

不多说，完善一下。

完善数据核心层

在数据实体层（SF.Framework.Entity）中，我们以一级文件夹区分了不同数据库的数据实体，如下图：

也是因此，在数据核心层（SF.Framework.DataCore）中定义EF数据上下文（MasterEntityContext）时，特地以Master作为类前缀来进行区分，实体配置工厂（MasterConfigurationFactory）也是同样的处理。

观察这2个类，简单有规则，完全可以用T4来自动生成。反射数据实体层，获取每个数据实体的命名空间的最后的名称（比如从S.Framework.Entity.Master获取Master），作为前缀去生成EF数据库上下文类和实体配置工厂类。

就这么办。创建2个模板，分别作为EF数据库上下文模板和实体配置工厂模板。

数据库上下文模板：

<#+
// <copyright file="EntityContext.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class EntityContext : CSharpTemplate
{
    private string _prefixName;

    public EntityContext(string prefixName)
    {
        _prefixName = prefixName;
    }
	public override string TransformText()
	{
		base.TransformText();
#>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;

using S.Framework.DataCore.EntityFramework.ConfigurationFactories;

namespace S.Framework.DataCore.EntityFramework.EntityContexts
{
	/// <summary>
    /// 数据库上下文
    /// </summary>
    public class <#= _prefixName #>EntityContext : System.Data.Entity.DbContext
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="nameOrConnectionString">数据库名称或连接字符串。</param>
        public <#= _prefixName #>EntityContext(string nameOrConnectionString)
            : base(nameOrConnectionString)
        { }

        /// <summary>
        /// 模型配置重写
        /// </summary>
        /// <param name="modelBuilder">数据实体生成器</param>
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            // 禁用一对多级联删除
            modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
            // 禁用多对多级联删除
            modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
            // 禁用表名自动复数规则
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

            <#= _prefixName #>ConfigurationFactory.ConfigurationsInit(modelBuilder.Configurations);
        }
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

实体配置工厂模板：

<#+
// <copyright file="ConfigurationFactory.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class ConfigurationFactory : CSharpTemplate
{
    private string _prefixName;

    public ConfigurationFactory(string prefixName)
    {
        _prefixName = prefixName;
    }
	public override string TransformText()
	{
		base.TransformText();
#>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity.ModelConfiguration.Configuration;

using S.Utilities;

namespace S.Framework.DataCore.EntityFramework.ConfigurationFactories
{
	/// <summary>
    /// 实体配置工厂类
    /// </summary>
    public static class <#= _prefixName #>ConfigurationFactory
    {
        /// <summary>
        /// 同步对象
        /// </summary>
        private static readonly object sync = new object();

        /// <summary>
        /// 唯一实例
        /// </summary>
        private static IEnumerable<IEntityConfiguration> singleton;

        /// <summary>
        /// 实体配置
        /// </summary>
        private static IEnumerable<IEntityConfiguration> Configurations
        {
            get
            {
                if (singleton == null)
                {
                    lock (sync)
                    {
                        if (singleton == null)
                        {
                            var types = typeof(IEntityConfiguration).GetSubClass().Where(w => !w.IsAbstract && w.Namespace.EndsWith("<#= _prefixName #>"));

                            singleton = types.Select(m => Activator.CreateInstance(m) as IEntityConfiguration);
                        }
                    }
                }

                return singleton;
            }
        }

        /// <summary>
        /// 初始化实体模型生成器
        /// </summary>
        /// <param name="configurations">实体模型生成器</param>
        public static void ConfigurationsInit(ConfigurationRegistrar configurations)
        {
            foreach (var configuration in Configurations)
            {
                configuration.RegistTo(configurations);
            }
        }
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

设计好模板之后，调整一下执行器文件的代码，就可以了。修改后的执行器代码如下：

<#@ template language="C#" debug="True" #>
<#@ assembly name="System.Core" #>
<#@ output extension="cs" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="T4Toolbox.tt" #>
<#@ include file="Configuration.tt" #>
<#@ include file="ConfigurationFactory.tt" #>
<#@ include file="EntityContext.tt" #>
<#

    string coreName = "S.Framework", projectName = coreName + ".DataCore", entityProjectName = coreName + ".Entity";
    string entityBaseModelName = entityProjectName + ".EntityBaseModel";
    string entityBaseModelNameForReflection = entityProjectName + ".EntityModelBaseForReflection";
    //当前完整路径
    string currentPath = Path.GetDirectoryName(Host.TemplateFile);
    //T4文件夹的父级文件夹路径
    string projectPath = currentPath.Substring(0, currentPath.IndexOf(@"T4"));
    //解决方案路径
    string solutionFolderPath = currentPath.Substring(0, currentPath.IndexOf(@"" + projectName));

    //加载数据实体.dll
    string entityFilePath = string.Concat(solutionFolderPath, ("\"+ entityProjectName +"\bin\Debug\" + entityProjectName + ".dll"));
    byte[] fileData = File.ReadAllBytes(entityFilePath);
    Assembly assembly = Assembly.Load(fileData);
    //反射出实体类，不知道为啥此处不能成功判定“是否继承EntityModelBaseForReflection类”
    //因此只能通过名称比较的方式来判定
    IEnumerable<Type> modelTypes = assembly.GetTypes().Where(m => m.IsClass && !m.IsAbstract && (m.BaseType.FullName.Equals(entityBaseModelName) || m.BaseType.FullName.Equals(entityBaseModelNameForReflection)));

    //循环实体类
    List<string> prefixNames = new List<string>();
    foreach (Type item in modelTypes)
    {
        //找 实体文件夹 名称
        string tempNamespace= item.Namespace, nameSpaceWithoutProjectName = tempNamespace.Substring(entityProjectName.Length);
        if(nameSpaceWithoutProjectName.IndexOf(".") != 0 || nameSpaceWithoutProjectName.LastIndexOf(".") > 0)
        { continue; }

        //是否直接继承实体基本类
        bool purity = item.BaseType.FullName.Equals(entityBaseModelNameForReflection);
        //实体所在的数据库标识名称
        string targetName = nameSpaceWithoutProjectName.Substring(1);
        if(!prefixNames.Any(a => a == targetName)){ prefixNames.Add(targetName); }
        //目标文件的路径和名称（嵌套Generate文件夹是为了标识T4生成的类文件）
        string fileName= targetName + @"Generate" + item.Name + "Configuration.cs";

        //配置文件
        string folderName= @"Configurations";
        Configuration configuration = new Configuration(item.Name, targetName, purity);
        configuration.Output.Encoding = Encoding.UTF8;
        string path = projectPath + folderName + fileName;
        configuration.RenderToFile(path);
    }

    foreach(string prefixName in prefixNames)
    {
        //配置工厂文件
        string fileName = prefixName + "ConfigurationFactory.Generate.cs";
        ConfigurationFactory configurationFactory = new ConfigurationFactory(prefixName);
        configurationFactory.Output.Encoding = Encoding.UTF8;
        string path = string.Format(@"{0}ConfigurationFactories", projectPath) + fileName;
        configurationFactory.RenderToFile(path);

        //数据库上下文文件
        fileName = prefixName + "EntityContext.Generate.cs";
        EntityContext entityContext = new EntityContext(prefixName);
        entityContext.Output.Encoding = Encoding.UTF8;
        path = string.Format(@"{0}EntityContexts", projectPath) + fileName;
        entityContext.RenderToFile(path);
    }
#>

运行一下执行器，发现EF数据库上下文和实体配置工厂都自动创建了。此时可以删除旧的EF数据库上下文和实体配置工厂。文档结构目录如下图：

编译，重新登录一下试试，没问题就好。

完善数据实现层

同样的，在数据实现层（S.Framework.DataAchieve）中，数据库初始化操作类（MasterDatabaseInitializer）也可以用相同的做法来自动生成。

创建2个模板文件，分别表示数据库初始化策略配置类模板和数据库初始化类模板，如下图：

数据库初始化策略配置模板：

<#+
// <copyright file="MigrateConfiguration.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class MigrateConfiguration : CSharpTemplate
{
    private string _prefixName;

    public MigrateConfiguration(string prefixName)
    {
        this._prefixName = prefixName;
    }

	public override string TransformText()
	{
		base.TransformText();
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity.Migrations;

using S.Framework.DataCore.EntityFramework.EntityContexts;

namespace S.Framework.DataAchieve.EntityFramework.Initializes
{
	/// <summary>
    /// <#= _prefixName #> 数据库迁移策略
    /// </summary>
    internal sealed class <#= _prefixName #>MigrateConfiguration : DbMigrationsConfiguration<<#= _prefixName #>EntityContext>
    {
        /// <summary>
        /// 构造方法
        /// </summary>
        public <#= _prefixName #>MigrateConfiguration()
        {
            //表示开启自动合并
            this.AutomaticMigrationsEnabled = true;
            //表示将导致数据丢失的合并也允许进行
            this.AutomaticMigrationDataLossAllowed = true;
        }

        /// <summary>
        /// 数据初始化
        /// </summary>
        /// <param name="context">数据库上下文</param>
        protected override void Seed(<#= _prefixName #>EntityContext context)
        {
            //<#= _prefixName #>DataInit.DataInit(context);
        }
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

数据库初始化模板：

<#+
// <copyright file="DatabaseInitializer.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class DatabaseInitializer : CSharpTemplate
{
    private string _prefixName;

    public DatabaseInitializer(string prefixName)
    {
        this._prefixName = prefixName;
    }

	public override string TransformText()
	{
		base.TransformText();
#>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;

using S.Framework.DataCore.EntityFramework.EntityContexts;

namespace S.Framework.DataAchieve.EntityFramework.Initializes
{
	/// <summary>
    /// <#= _prefixName #> 数据库初始化操作类
    /// </summary>
    public class <#= _prefixName #>DatabaseInitializer
    {
        /// <summary>
        /// 设置数据库初始化策略
        /// </summary>
        /// <param name="migrate">是否合并（自动迁移）。若是，则会检查数据库是否存在，若不存在则创建，若存在则进行自动迁移。若否，则不进行初始化操作（这样能避开EF访问sys.databases检测数据库是否存在，项目稳定后可将参数设置为false）。</param>
        public void Initialize(bool migrate)
        {
            if (!migrate)
            {
                System.Data.Entity.Database.SetInitializer<<#= _prefixName #>EntityContext>(null);
            }
            else
            {
                System.Data.Entity.Database.SetInitializer(new MigrateDatabaseToLatestVersion<<#= _prefixName #>EntityContext, <#= _prefixName #>MigrateConfiguration>(true));
            }
        }
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

设计好模板之后，调整一下执行器文件的代码，就可以了。修改后的执行器代码如下：

<#@ template language="C#" debug="True" #>
<#@ assembly name="System.Core" #>
<#@ output extension="cs" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="T4Toolbox.tt" #>
<#@ include file="Repository.tt" #>
<#@ include file="MigrateConfiguration.tt" #>
<#@ include file="DatabaseInitializer.tt" #>
<#

    string coreName = "S.Framework", projectName = coreName + ".DataAchieve", entityProjectName = coreName + ".Entity";
    string entityBaseModelName = entityProjectName + ".EntityBaseModel";
    string entityBaseModelNameForReflection = entityProjectName + ".EntityModelBaseForReflection";
    //当前完整路径
    string currentPath = Path.GetDirectoryName(Host.TemplateFile);
    //T4文件夹的父级文件夹路径
    string projectPath = currentPath.Substring(0, currentPath.IndexOf(@"T4"));
    //解决方案路径
    string solutionFolderPath = currentPath.Substring(0, currentPath.IndexOf(@"" + projectName));

    //加载数据实体.dll
    string entityFilePath = string.Concat(solutionFolderPath, ("\"+ entityProjectName +"\bin\Debug\" + entityProjectName + ".dll"));
    byte[] fileData = File.ReadAllBytes(entityFilePath);
    Assembly assembly = Assembly.Load(fileData);
    //反射出实体类，不知道为啥此处不能成功判定“是否继承EntityModelBaseForReflection类”
    //因此只能通过名称比较的方式来判定
    IEnumerable<Type> modelTypes = assembly.GetTypes().Where(m => m.IsClass && !m.IsAbstract && (m.BaseType.FullName.Equals(entityBaseModelName) || m.BaseType.FullName.Equals(entityBaseModelNameForReflection)));

    //循环实体类
    Dictionary<string, List<Type>> prefixModelTypes = new Dictionary<string, List<Type>>();//存储[数据库标识名称]和[实体类型集合]
    foreach (Type item in modelTypes)
    {
        //找 实体文件夹 名称
        string tempNamespace= item.Namespace, nameSpaceWithoutProjectName = tempNamespace.Substring(entityProjectName.Length);
        if(nameSpaceWithoutProjectName.IndexOf(".") != 0 || nameSpaceWithoutProjectName.LastIndexOf(".") > 0)
        { continue; }

        //是否直接继承实体基本类
        bool purity = item.BaseType.FullName.Equals(entityBaseModelNameForReflection);
        //实体所在的数据库标识名称
        string targetName = nameSpaceWithoutProjectName.Substring(1);
        List<Type> temp;
        if(prefixModelTypes.TryGetValue(targetName, out temp))
        {
            temp.Add(item);
        }
        else
        {
            temp = new List<Type>{ item };
            prefixModelTypes.Add(targetName, temp);
        }

        //目标文件的路径和名称（嵌套Generate文件夹是为了标识T4生成的类文件）
        string fileName= targetName + @"Generate" + item.Name + "Repository.cs";
        //仓储文件
        string folderName= @"Repositories";
        Repository repository = new Repository(item.Name, targetName);
        repository.Output.Encoding = Encoding.UTF8;
        string path = projectPath + folderName + fileName;
        repository.RenderToFile(path);
    }

    foreach(KeyValuePair<string, List<Type>> item in prefixModelTypes)
    {
        //数据库初始化策略配置文件
        string fileName = "/"+ item.Key +"/" + item.Key + "MigrateConfiguration.Generate.cs";
        MigrateConfiguration mc = new MigrateConfiguration(item.Key);
        mc.Output.Encoding = Encoding.UTF8;
        string path = string.Format(@"{0}Initializes", projectPath) + fileName;
        mc.RenderToFile(path);

        //数据库初始化类文件
        fileName = "/"+ item.Key +"/" + item.Key + "DatabaseInitializer.Generate.cs";
        DatabaseInitializer temp = new DatabaseInitializer(item.Key);
        temp.Output.Encoding = Encoding.UTF8;
        path = string.Format(@"{0}Initializes", projectPath) + fileName;
        temp.RenderToFile(path);
    }
#>

T4执行后的文件结构目录如下图：

其中的MasterDataInit.cs是手动创建的，用来个性化地往数据库中添加指定初始数据：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using S.Framework.DataCore.EntityFramework.EntityContexts;
using S.Framework.Entity.Master;

namespace S.Framework.DataAchieve.EntityFramework.Initializes
{
    internal class MasterDataInit
    {
        internal static void DataInit(MasterEntityContext context)
        {
            //判断admin是否存在，若存在，不新增
            var dbSet = context.Set<SysUser>();
            if (!dbSet.Any(a => a.UserName == "admin"))
            {
                var entity = new SysUser { ID = Guid.NewGuid().ToString(), UserName = "admin", Password = "123456", CreateDate = DateTime.Now, CreateUser = "admin" };
                //将用户对象附加给数据库上下文（这仅仅是内存级别的操作）
                dbSet.Add(entity);
                //数据库上下文保存更改（提交变更到数据库执行）
                context.SaveChanges();
            }
        }
    }
}

然后还需要修改MasterMigrateConfiguration.Generate.cs，在Seed中调用一下MasterDataInit的方法即可。

编译，重新登录一下试试，没问题就好。

统一数据库配置信息

创建类库项目，名称S.Framework，定义一个数据库配置类（DatabaseConfig.cs）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using S.Utilities;

namespace S.Framework
{
    public class DatabaseConfig
    {
        /// <summary>
        /// web.config文件中数据库连接字符串的名称
        /// </summary>
        public static string ConnectionStringName = "matrixkey";
        /// <summary>
        /// 默认的数据库管道名称
        /// </summary>
        public static readonly string DefaultProviderName = "System.Data.SqlClient";

        private static string _connectioonString = string.Empty;
        private static string _providerName = string.Empty;

        /// <summary>
        /// 数据连接字符串
        /// </summary>
        public static string ConnectionString
        {
            get
            {
                if (string.IsNullOrEmpty(_connectioonString))
                {
                    string tempConnectionString = string.Empty, tempProviderName = string.Empty;
                    if (ConfigHelper.TryGetConnectionInfo(ConnectionStringName, out tempConnectionString, out tempProviderName))
                    {
                        _connectioonString = tempConnectionString;
                        _providerName = tempProviderName;
                    }
                }
                if (string.IsNullOrWhiteSpace(_connectioonString))
                {
                    throw ExceptionHelper.ThrowConfigException("不存在名为“" + ConnectionStringName + "”的数据库连接信息，请检查web.config文件中的设置。");
                }
                return _connectioonString;
            }
        }

        /// <summary>
        /// 数据提供程序
        /// </summary>
        public static string ProviderName
        {
            get
            {
                if (string.IsNullOrEmpty(_providerName))
                {
                    _providerName = ConfigHelper.ProviderName(ConnectionStringName);
                }
                if (string.IsNullOrWhiteSpace(_providerName))
                {
                    _providerName = DefaultProviderName;
                }
                return _providerName;
            }
        }

        /// <summary>
        /// 表示WEB应用程序在初次使用数据库时，是否自动合并/迁移数据库。该属性只在 <see cref="DataDriven"/> 值为 EntityFramework 时有效。
        /// 该属性配置项由 Web.config/configuration/appSettings/Database:Migrate 参数指定。
        /// </summary>
        public static bool IsMigrateDatabase
        {
            get
            {
                string tempIsMigrateDatabase = string.Empty;
                if (ConfigHelper.TryGetAppSettingInfo("Database:Migrate", out tempIsMigrateDatabase))
                { }
                return string.IsNullOrEmpty(tempIsMigrateDatabase) ? false : tempIsMigrateDatabase.ToBoolean(false);
            }
        }
    }
}

在Web.config/appSettings中增加配置参数：

<!--表示WEB应用程序在初次使用数据库时，是否自动合并/迁移数据库。-->
<add key="Database:Migrate" value="true" />

然后就是使用定义的配置。

让WebUI层引用S.Framework，然后把WebUI层中的Global.asax中的

new MasterDatabaseInitializer().Initialize(true);

修改成

new MasterDatabaseInitializer().Initialize(S.Framework.DatabaseConfig.IsMigrateDatabase);

让S.Framework.DataAchieve层引用S.Framework，然后修改BaseRepository.cs的构造方法，把

this.Db = new MasterEntityContext("matrixkey");

修改成

this.Db = new MasterEntityContext(S.Framework.DatabaseConfig.ConnectionStringName);

总结一下，这篇日志演示了3处整理：

1、利用T4自动生成EF数据库上下文和实体配置工厂

2、利用T4自动生成数据库初始化策略和初始化类

3、统一配置数据库参数

下个章节将演示仓储接口的创建。

截止本章节，项目源码下载：点击下载（存在百度云盘中）