仓储空间利用

基于EntityFramework的数据访问层，我计划细分成数据核心、数据接口和数据实现。

其中数据核心已经在前几个章节中创建，那么在这篇日志里，将演示数据仓储（接口和实现）的实现及封装架构的整个过程。

 

仓储的作用

仓储的概念请自行搜索了解，我认为它最大的作用就是解耦。没有仓储，就只能直接使用EF数据库上下文对象来操作数据库，而为了“能使用EF数据库上下文对象来操作数据库（各实体库）”，就必须把实体关联给EF数据库上下文。例如MasterEntityContext中的DbSet属性：

/// <summary>
/// 用户
/// </summary>
public DbSet<SysUser> Users { get; set; }

/// <summary>
/// 角色
/// </summary>
public DbSet<SysRole> Roles { get; set; }

只有这样，我们才能在初始化EF数据库上下文对象之后，通过对象来访问相应的实体库，比如登录判定中那句代码：

var db = new MasterEntityContext("matrixkey");
var entity = db.Users.Where(w => w.UserName == model.UserName).FirstOrDefault();

上述代码中的db.Users，其中Users对象，就是EF数据库上下文中定义的属性。

在WebUI层直接使用数据访问层的核心对象，这无疑是非常不正确的。在后面的日志中，我们将增加业务逻辑层，作为数据访问层和WebUI层的桥梁。

但是若没有仓储，即使有了业务逻辑层，仍然只能通过直接使用EF数据库上下文对象的方式来操作数据库，这就需要：

1、在业务层中暴露EF数据库上下文对象

2、在业务层中引用EntityFramework

这依旧很糟糕，有了EF数据库上下文对象，就等于有了一切。不能让业务层拥有一切，也不能让业务层引用EntityFramework。

于是就需要仓储作为“EF数据库上下文和业务层之间的桥梁”。对于业务层而言，仓储才是真正的数据访问层，业务层根本不知道EF数据库上下文的存在，它不关心数据访问层中究竟是谁提供了数据库访问的能力，无论是EF或是dapper或是源生的ADO.NET，它只关心数据访问层是否执行了它要操作的动作。

总之，业务层是无关数据驱动的，不能把EF暴露给业务层。仓储的实现，解耦了数据核心层和业务层，并且在下一章节中，还将解耦数据实体层和数据核心层。可见仓储最大的作用就是解耦。

 

用户仓储的简易实现

在解决方案下新建类库项目，名称S.Framework.DataAchieve。再创建相应的文件夹进行区分，结构如下图：

在Master下创建用户仓储类，名称SysUserRepository。上面说过，仓储是桥梁，是为其他需要获取数据的项目层提供代理服务的，那么在仓储类中，需要定义EF数据库上下文对象，以及通过该上下文对象对数据库的各种操作的方法的封装。

毫无疑问，数据实现层需要引用“数据实体层、数据核心层”。

这里以“用户登录功能”作为范例，一步一步演示用户仓储中的代码的演变：

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

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

namespace S.Framework.DataAchieve.EntityFramework.Repositories.Master
{
    /// <summary>
    /// 用户仓储
    /// </summary>
    public class SysUserRepository
    {

    }
}

定义数据库上下文对象：

/// <summary>
/// 数据库上下文
/// </summary>
private MasterEntityContext Db
{
    get;
    set;
}

数据库上下文对象作为最核心的内容，只允许在当前类中被设置和获取，因此该属性的访问修饰符设置为private。

定义用户仓储的构造方法，并在方法中初始化数据库上下文对象：

public SysUserRepository()
{
    this.Db = new MasterEntityContext("matrixkey");
}

“用户登录功能”中需要根据用户名获取用户实体，可以在仓储中定义该方法：

/// <summary>
/// 根据用户名获取用户实体
/// </summary>
/// <param name="userName">用户名</param>
/// <returns>用户实体</returns>
public SysUser GetByUserName(string userName)
{
    return this.Db.Users.Where(w => w.UserName == userName).FirstOrDefault();
}

理论上来说，用户仓储已经完成。

 

用户仓储功能检验结果

先在WebUI项目中增加对数据实现层（S.Framework.DataAchieve）的引用（对数据核心层的引用继续留着，因为数据库初始化策略的设置要用到核心层，等会会把数据库初始化设置从核心层移出去，那时再移除WebUI层对数据核心层的引用）。

把“用户登录功能”的代码调整为对用户仓储的调用，将

var db = new MasterEntityContext("matrixkey");
var entity = db.Users.Where(w => w.UserName == model.UserName).FirstOrDefault();

修改为：

var rep = new SysUserRepository();
var entity = rep.GetByUserName(model.UserName);

编译运行，用admin和123456进行登录，成功跳转至首页。

 

解耦数据核心层与WebUI层

上面说到，由于数据库初始化策略及其设置，都定义在数据核心层中，所以WebUI层需要依赖数据核心层。不能忍，必须解耦，方法是将数据库初始化策略及其设置类，移动到数据实现层中，如下图：

此时可以把数据核心层中EntityFramework文件夹下的Migrations、Initializes子文件夹删除。然后调整WebUI层中Global的命名空间即可。

编译，可能会有“找不到命名空间”的报错，原因是旧命名空间不存在了，删除这条using即可。

编译生成无误，然后移除WebUI层对数据核心层的引用吧。

由于数据库初始化类调整过，因此需要删除数据库让EF重新创建一次。删除数据库，重新去登录页面尝试登录。

 

仓储的完善

对实体的常用操作，可以简单地归纳为“特定查询、添加、更新、删除”，这几类操作是每一个实体仓储都需要包含的，因此可以通过封装来精简代码量。

建立一个仓储基本类，名称BaseRepository，将通用的部分在基本类中实现，如下：

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

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

namespace S.Framework.DataAchieve.EntityFramework
{
    public abstract class BaseRepository<TEntity> where TEntity : class, new()
    {
        private System.Data.Entity.DbContext Db { get; set; }

        private System.Data.Entity.DbSet<TEntity> DbSet { get { return this.Db.Set<TEntity>(); } }

        public BaseRepository()
        {
            this.Db = new MasterEntityContext("matrixkey");
        }

        /// <summary>
        /// 主键查询
        /// </summary>
        /// <param name="keyValues">键值</param>
        /// <returns>实体</returns>
        public virtual TEntity Find(IEnumerable<object> keyValues)
        {
            if (keyValues == null || keyValues.Count() == 0)
            {
                throw new ArgumentException("参数有误。");
            }
            keyValues = keyValues.Where(keyValue => keyValue != null);
            return this.DbSet.Find(keyValues);
        }

        /// <summary>
        /// 主键查询
        /// </summary>
        /// <param name="keyValues">键值</param>
        /// <returns>实体</returns>
        public virtual TEntity Find(params object[] keyValues)
        {
            if (keyValues == null || keyValues.Count() == 0)
            {
                throw new ArgumentException("参数有误。");
            }

            return this.DbSet.Find(keyValues);
        }

        /// <summary>
        /// 获取 <see cref="TEntity"/> 的Linq查询器
        /// </summary>
        /// <returns></returns>
        protected IQueryable<TEntity> Query()
        {
            return this.DbSet.AsQueryable();
        }

        /// <summary>
        /// 获取 <see cref="TEntity"/> 的Linq查询器
        /// </summary>
        /// <param name="predicate">查询条件</param>
        /// <returns>数据查询器</returns>
        protected IQueryable<TEntity> Query(Expression<Func<TEntity, bool>> predicate)
        {
            return this.DbSet.Where(predicate);
        }

        /// <summary>
        /// 添加实体
        /// </summary>
        /// <param name="entity">实体</param>
        public void Add(TEntity entity)
        {
            if (entity == null)
            { return; }

            this.DbSet.Add(entity);
        }

        /// <summary>
        /// 批量添加实体
        /// </summary>
        /// <param name="entities">实体集合</param>
        public void AddRange(IEnumerable<TEntity> entities)
        {
            if (entities == null || entities.Count() == 0)
            { return; }

            System.Data.Entity.DbSet<TEntity> set = this.DbSet;
            bool autoDetectChangesEnabled = this.Db.Configuration.AutoDetectChangesEnabled;
            this.Db.Configuration.AutoDetectChangesEnabled = false;

            foreach (TEntity entity in entities)
            {
                if (entity == null)
                { continue; }

                set.Add(entity);
            }

            this.Db.Configuration.AutoDetectChangesEnabled = autoDetectChangesEnabled;
        }

        /// <summary>
        /// 更改实体
        /// </summary>
        /// <param name="entity">实体对象</param>
        public void Update(TEntity entity)
        {
            if (entity == null)
            { return; }

            System.Data.Entity.Infrastructure.DbEntityEntry<TEntity> entry = this.Db.Entry(entity);
            if (entry.State == System.Data.Entity.EntityState.Detached)
            {
                this.DbSet.Attach(entity);
            }
            entry.State = System.Data.Entity.EntityState.Modified;
        }

        /// <summary>
        /// 批量更改实体
        /// </summary>
        /// <param name="entities">实体集合</param>
        public void UpdateRange(IEnumerable<TEntity> entities)
        {
            if (entities == null || entities.Count() == 0)
            { return; }

            var set = this.DbSet;
            bool autoDetectChangesEnabled = this.Db.Configuration.AutoDetectChangesEnabled;
            this.Db.Configuration.AutoDetectChangesEnabled = false;

            foreach (TEntity entity in entities)
            {
                if (entity == null)
                { continue; }

                System.Data.Entity.Infrastructure.DbEntityEntry<TEntity> entry = this.Db.Entry(entity);
                if (entry.State == System.Data.Entity.EntityState.Detached)
                {
                    set.Attach(entity);
                }
                entry.State = System.Data.Entity.EntityState.Modified;
            }

            this.Db.Configuration.AutoDetectChangesEnabled = autoDetectChangesEnabled;
        }

        /// <summary>
        /// 主键删除实体
        /// </summary>
        /// <param name="key">键值</param>
        public void Delete(object key)
        {
            if (key == null || string.IsNullOrWhiteSpace(key.ToString()))
            { return; }

            TEntity entity = this.Find(key);

            this.Delete(entity);
        }

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="entity">实体</param>
        public void Delete(TEntity entity)
        {
            if (entity == null)
            { return; }

            System.Data.Entity.DbSet<TEntity> set = this.DbSet;
            System.Data.Entity.Infrastructure.DbEntityEntry<TEntity> entry = this.Db.Entry(entity);
            if (entry.State == System.Data.Entity.EntityState.Detached)
            {
                set.Attach(entity); set.Remove(entity);
            }
            else
            { entry.State = System.Data.Entity.EntityState.Deleted; }
        }

        /// <summary>
        /// 批量删除实体
        /// </summary>
        /// <param name="entities">实体集合</param>
        public void DeleteRange(IEnumerable<TEntity> entities)
        {
            if (entities == null || entities.Count() == 0)
            { return; }
            var set = this.DbSet;

            bool autoDetectChangesEnabled = this.Db.Configuration.AutoDetectChangesEnabled;
            this.Db.Configuration.AutoDetectChangesEnabled = false;

            foreach (TEntity entity in entities)
            {
                if (entity == null)
                { continue; }

                System.Data.Entity.Infrastructure.DbEntityEntry<TEntity> entry = this.Db.Entry(entity);
                if (entry.State == System.Data.Entity.EntityState.Detached)
                {
                    set.Attach(entity);
                }
                else
                {
                    entry.State = System.Data.Entity.EntityState.Deleted;
                }
            }

            this.Db.Configuration.AutoDetectChangesEnabled = autoDetectChangesEnabled;
        }
    }
}

注意仓储基本类的修饰符以及类中各属性、方法等成员的访问修饰符，要充分理解abstract、private、protected、public的使用原因。不了解泛型的读者请自行查阅相关资料。

现在让用户仓储类继承仓储基本类，并删除“在父类中已经实现的成员几相关代码”，用户仓储类将变得非常简单：

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

using S.Framework.Entity.Master;

namespace S.Framework.DataAchieve.EntityFramework.Repositories.Master
{
    /// <summary>
    /// 用户仓储
    /// </summary>
    public class SysUserRepository : BaseRepository<SysUser>
    {
        /// <summary>
        /// 根据用户名获取用户实体
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <returns>用户实体</returns>
        public SysUser GetByUserName(string userName)
        {
            return this.Query(w => w.UserName == userName).FirstOrDefault();
        }
    }
}

编译运行，再次进行登录，成功跳转至首页。

 

现在为角色实体创建仓储类试试，简单吧。

但同时也引出新问题：手动为每个实体创建实体仓储是个重复又机械的体力活，是否可以像“实体配置类”那样也用T4模板来自动生成？

当然可以。过程和“利用T4自动生成实体配置类”一样，模板不同而已，这里一笔带过，直接贴出“仓储模板”和“执行器”的相关代码：

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

public class Repository : CSharpTemplate
{
    private string _modelName;
    private string _prefixName;

    public Repository(string modelName, string prefixName)
    {
        this._modelName = modelName;
        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 S.Framework.Entity.<#= _prefixName #>;

namespace S.Framework.DataAchieve.EntityFramework.Repositories.<#= _prefixName #>
{
	/// <summary>
    /// 实体仓储
    /// </summary>
    public partial class <#= _modelName #>Repository : BaseRepository<<#= _modelName #>>
	{

	}
}
<#+
        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" #>
<#

    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)));

    //循环实体类
    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 + "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);
    }
#>

通过T4模板生成的实体仓储文件，结构如下图：

 

下一篇日志，将演示数据实体层和数据核心层的解耦。

 

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