TinyFrame升级之二：数据底层访问部分

在上一篇中，我列举了框架的整体结构，下面我们将一一说明：

首先需要说明的是TinyFrame.Data。

它主要用于处理数据库底层操作。包含EF CodeFirst，Repository，Unitofwork三个部分。

其中，DomainModel主要是用来存放实体类的：

namespace TinyFrame.Data.DomainModel
{
    public class Book
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string Author { get; set; }
        public string Publishment { get; set; }
        public int BookTypeID { get; set; }
        public int BookPlaceID { get; set; }

        public virtual BookType BookType { get; set; }
        public virtual BookPlace BookPlace { get; set; }
    }
}

然后，在DomainMapper中，则主要处理数据库字段属性和主外键映射：

using System.Data.Entity.ModelConfiguration;
using System.ComponentModel.DataAnnotations.Schema;
using TinyFrame.Data.DomainModel;

namespace TinyFrame.Data.DomainMapper
{
    public class BookMapper:EntityTypeConfiguration<Book>
    {
        public BookMapper()
        {
            this.ToTable("Book");

            this.HasKey(c => c.ID);
            this.Property(c => c.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
            this.Property(c => c.ID).IsRequired();

            this.Property(c => c.Name).HasMaxLength(255);
            this.Property(c => c.Name).IsRequired();

            this.Property(c => c.Author).HasMaxLength(255);
            this.Property(c => c.Author).IsOptional();

            this.Property(c => c.Publishment).HasMaxLength(255);
            this.Property(c => c.Publishment).IsRequired();

            this.HasRequired(c => c.BookType).WithMany().HasForeignKey(s => s.BookTypeID).WillCascadeOnDelete(false);
            this.HasRequired(c => c.BookPlace).WithMany().HasForeignKey(s => s.BookPlaceID).WillCascadeOnDelete(false);

        }
    }
}

上面的代码中，ToTable方法适用于生成数据库新表；HasKey方法则指定主键；Property方法则用于设置字段属性；至于最后两句则主要用于设定主外键映射的，这里我们不做过多讲解。

最后在DataContext中，我们需要进行配置：

using System;
using System.Data.Entity;
using System.Data.Entity.Validation;
using TinyFrame.Data.DomainModel;
using TinyFrame.Data.DomainMapper;

namespace TinyFrame.Data.DataContext
{
    public class BookContext : DbContext, IDbContext
    {
        public BookContext()
            : base("BookConnection")
        {
            Configuration.ProxyCreationEnabled = false;
            Configuration.LazyLoadingEnabled = true;
            Database.SetInitializer(new MigrateDatabaseToLatestVersion<BookContext, BookContextMConfig>());
        }

        public DbSet<Book> Books { get; set; }
        public DbSet<Student> Students { get; set; }
        public DbSet<BookLend> BookLends { get; set; }
        public DbSet<BookType> BookTypes { get; set; }
        public DbSet<BookPlace> BookPlaces { get; set; }
        public DbSet<Manager> Managers { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.Add(new BookMapper());
            modelBuilder.Configurations.Add(new BookLendMapper());
            modelBuilder.Configurations.Add(new BookTypeMapper());
            modelBuilder.Configurations.Add(new BookPlaceMapper());
            modelBuilder.Configurations.Add(new StudentMapper());
            modelBuilder.Configurations.Add(new ManagerMapper());
            base.OnModelCreating(modelBuilder);
        }

        public new IDbSet<T> Set<T>() where T : class
        {
            return base.Set<T>();
        }
    }
}

这里说明一下，OnModelCreating主要用于配置数据库实体类映射，我们可以把自定义的配置添加进来，最后通过调用OnModelCreating方法来触发数据库表创建事件。

至于Repository模式，则主要提供数据操作集合：

using System;
using System.Linq;
using System.Linq.Expressions;

namespace TinyFrame.Data.DataRepository
{
    public interface IRepository<T> where T:class
    {
        T GetByID(long id);
        T GetByID(int id);
        T GetByID(Guid id);
        T GetByID(string id);
        T Get(Expression<Func<T, bool>> where);
        IQueryable<T> GetMany(Expression<Func<T, bool>> where);

        void Insert(T entity);
        void Update(T entity);
        void Delete(T entity);
        void Delete(Expression<Func<T, bool>> where);
    }
}

其具体的实现如下：

using System;
using System.Linq;
using System.Data.Entity;
using System.Linq.Expressions;
using System.Data.Entity.Validation;
using TinyFrame.Data.DataContext;

namespace TinyFrame.Data.DataRepository
{
    public class Repository<T>:IRepository<T> where T:class
    {
        public Repository(IDbContext context)
        {
            this.context = context;
        }

        private IDbContext context;

        private IDbSet<T> dbset;
        public virtual IDbSet<T> DbSet
        {
            get
            {
                if (dbset == null)
                    dbset = context.Set<T>();
                return dbset;
            }
        }

        public virtual T GetByID(long id)
        {
            return DbSet.Find(id);
        }

        public virtual T GetByID(int id)
        {
            return DbSet.Find(id);
        }

        public virtual T GetByID(Guid id)
        {
            return DbSet.Find(id);
        }

        public virtual T GetByID(string id)
        {
            return DbSet.Find(id);
        }

        public virtual T Get(Expression<Func<T, bool>> where)
        {
            return DbSet.Where(where).FirstOrDefault<T>();
        }

        public virtual IQueryable<T> GetMany(Expression<Func<T, bool>> where)
        {
            return DbSet.Where(where);
        }

        public virtual void Insert(T entity)
        {
            try
            {
                if (entity == null)
                    throw new ArgumentException("实体类为空");
                DbSet.Add(entity);
                context.SaveChanges();
            }
            catch (DbEntityValidationException dbex)
            {
                var msg = string.Empty;
                foreach(var validationErrors in dbex.EntityValidationErrors)
                    foreach(var validateionError in validationErrors.ValidationErrors)
                        msg+=string.Format("Property:{0} Error:{1}",validateionError.PropertyName,validateionError.ErrorMessage);

                var fail = new Exception(msg,dbex);
                throw fail;
            }
        }

        public virtual void Update(T entity)
        {
            try
            {
                if (entity == null)
                    throw new ArgumentNullException("实体类为空");
                context.SaveChanges();
            }
            catch (DbEntityValidationException dbex)
            {
                var msg = string.Empty;
                foreach (var validationErrors in dbex.EntityValidationErrors)
                    foreach (var validateionError in validationErrors.ValidationErrors)
                        msg += string.Format("Property:{0} Error:{1}", validateionError.PropertyName, validateionError.ErrorMessage);

                var fail = new Exception(msg, dbex);
                throw fail;
            }
        }

        public virtual void Delete(T entity)
        {
            try
            {
                if (entity == null)
                    throw new ArgumentNullException("实体类为空");
                DbSet.Remove(entity);
                context.SaveChanges();
            }
            catch (DbEntityValidationException dbex)
            {
                var msg = string.Empty;
                foreach (var validationErrors in dbex.EntityValidationErrors)
                    foreach (var validateionError in validationErrors.ValidationErrors)
                        msg += string.Format("Property:{0} Error:{1}", validateionError.PropertyName, validateionError.ErrorMessage);

                var fail = new Exception(msg, dbex);
                throw fail;
            }
        }

        public virtual void Delete(Expression<Func<T, bool>> where)
        {
            try
            {
                var entities = DbSet.Where(where);
                foreach (var entity in entities.ToList())
                    DbSet.Remove(entity);
                context.SaveChanges();
            }
            catch (DbEntityValidationException dbex)
            {
                var msg = string.Empty;
                foreach (var validationErrors in dbex.EntityValidationErrors)
                    foreach (var validateionError in validationErrors.ValidationErrors)
                        msg += string.Format("Property:{0} Error:{1}", validateionError.PropertyName, validateionError.ErrorMessage);

                var fail = new Exception(msg, dbex);
                throw fail;
            }
        }
    }
}

由于在编码中，我们使用了泛型对象，所以让数据库中有表变动的时候，不会影响到我们这层。

最后是Unitofwork，这个比较简单，主要用于事务控制：

namespace TinyFrame.Data.DataUnitOfWork
{
    public interface IUnitOfWork
    {
        void Commit();
    }
}

一旦有批量的数据CRUD的时候，我们可以调用此方法进行批量提交，这样能够保证CRUD的准确性。