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

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

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

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

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

   1:  namespace TinyFrame.Data.DomainModel
   2:  {
   3:      public class Book
   4:      {
   5:          public int ID { get; set; }
   6:          public string Name { get; set; }
   7:          public string Author { get; set; }
   8:          public string Publishment { get; set; }
   9:          public int BookTypeID { get; set; }
  10:          public int BookPlaceID { get; set; }
  11:
  12:          public virtual BookType BookType { get; set; }
  13:          public virtual BookPlace BookPlace { get; set; }
  14:      }
  15:  }

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

   1:  using System.Data.Entity.ModelConfiguration;
   2:  using System.ComponentModel.DataAnnotations.Schema;
   3:  using TinyFrame.Data.DomainModel;
   4:
   5:  namespace TinyFrame.Data.DomainMapper
   6:  {
   7:      public class BookMapper:EntityTypeConfiguration<Book>
   8:      {
   9:          public BookMapper()
  10:          {
  11:              this.ToTable("Book");
  12:
  13:              this.HasKey(c => c.ID);
  14:              this.Property(c => c.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
  15:              this.Property(c => c.ID).IsRequired();
  16:
  17:              this.Property(c => c.Name).HasMaxLength(255);
  18:              this.Property(c => c.Name).IsRequired();
  19:
  20:              this.Property(c => c.Author).HasMaxLength(255);
  21:              this.Property(c => c.Author).IsOptional();
  22:
  23:              this.Property(c => c.Publishment).HasMaxLength(255);
  24:              this.Property(c => c.Publishment).IsRequired();
  25:
  26:              this.HasRequired(c => c.BookType).WithMany().HasForeignKey(s => s.BookTypeID).WillCascadeOnDelete(false);
  27:              this.HasRequired(c => c.BookPlace).WithMany().HasForeignKey(s => s.BookPlaceID).WillCascadeOnDelete(false);
  28:
  29:          }
  30:      }
  31:  }

 

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

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

   1:  using System;
   2:  using System.Data.Entity;
   3:  using System.Data.Entity.Validation;
   4:  using TinyFrame.Data.DomainModel;
   5:  using TinyFrame.Data.DomainMapper;
   6:
   7:  namespace TinyFrame.Data.DataContext
   8:  {
   9:      public class BookContext : DbContext, IDbContext
  10:      {
  11:          public BookContext()
  12:              : base("BookConnection")
  13:          {
  14:              Configuration.ProxyCreationEnabled = false;
  15:              Configuration.LazyLoadingEnabled = true;
  16:              Database.SetInitializer(new MigrateDatabaseToLatestVersion<BookContext, BookContextMConfig>());
  17:          }
  18:
  19:          public DbSet<Book> Books { get; set; }
  20:          public DbSet<Student> Students { get; set; }
  21:          public DbSet<BookLend> BookLends { get; set; }
  22:          public DbSet<BookType> BookTypes { get; set; }
  23:          public DbSet<BookPlace> BookPlaces { get; set; }
  24:          public DbSet<Manager> Managers { get; set; }
  25:
  26:          protected override void OnModelCreating(DbModelBuilder modelBuilder)
  27:          {
  28:              modelBuilder.Configurations.Add(new BookMapper());
  29:              modelBuilder.Configurations.Add(new BookLendMapper());
  30:              modelBuilder.Configurations.Add(new BookTypeMapper());
  31:              modelBuilder.Configurations.Add(new BookPlaceMapper());
  32:              modelBuilder.Configurations.Add(new StudentMapper());
  33:              modelBuilder.Configurations.Add(new ManagerMapper());
  34:              base.OnModelCreating(modelBuilder);
  35:          }
  36:
  37:          public new IDbSet<T> Set<T>() where T : class
  38:          {
  39:              return base.Set<T>();
  40:          }
  41:      }
  42:  }

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

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

   1:  using System;
   2:  using System.Linq;
   3:  using System.Linq.Expressions;
   4:
   5:  namespace TinyFrame.Data.DataRepository
   6:  {
   7:      public interface IRepository<T> where T:class
   8:      {
   9:          T GetByID(long id);
  10:          T GetByID(int id);
  11:          T GetByID(Guid id);
  12:          T GetByID(string id);
  13:          T Get(Expression<Func<T, bool>> where);
  14:          IQueryable<T> GetMany(Expression<Func<T, bool>> where);
  15:
  16:          void Insert(T entity);
  17:          void Update(T entity);
  18:          void Delete(T entity);
  19:          void Delete(Expression<Func<T, bool>> where);
  20:      }
  21:  }

其具体的实现如下：

  1:  using System;
  2:  using System.Linq;
  3:  using System.Data.Entity;
  4:  using System.Linq.Expressions;
  5:  using System.Data.Entity.Validation;
  6:  using TinyFrame.Data.DataContext;
  7:
  8:  namespace TinyFrame.Data.DataRepository
  9:  {
 10:      public class Repository<T>:IRepository<T> where T:class
 11:      {
 12:          public Repository(IDbContext context)
 13:          {
 14:              this.context = context;
 15:          }
 16:
 17:          private IDbContext context;
 18:
 19:          private IDbSet<T> dbset;
 20:          public virtual IDbSet<T> DbSet
 21:          {
 22:              get
 23:              {
 24:                  if (dbset == null)
 25:                      dbset = context.Set<T>();
 26:                  return dbset;
 27:              }
 28:          }
 29:
 30:          public virtual T GetByID(long id)
 31:          {
 32:              return DbSet.Find(id);
 33:          }
 34:
 35:          public virtual T GetByID(int id)
 36:          {
 37:              return DbSet.Find(id);
 38:          }
 39:
 40:          public virtual T GetByID(Guid id)
 41:          {
 42:              return DbSet.Find(id);
 43:          }
 44:
 45:          public virtual T GetByID(string id)
 46:          {
 47:              return DbSet.Find(id);
 48:          }
 49:
 50:          public virtual T Get(Expression<Func<T, bool>> where)
 51:          {
 52:              return DbSet.Where(where).FirstOrDefault<T>();
 53:          }
 54:
 55:          public virtual IQueryable<T> GetMany(Expression<Func<T, bool>> where)
 56:          {
 57:              return DbSet.Where(where);
 58:          }
 59:
 60:          public virtual void Insert(T entity)
 61:          {
 62:              try
 63:              {
 64:                  if (entity == null)
 65:                      throw new ArgumentException("实体类为空");
 66:                  DbSet.Add(entity);
 67:                  context.SaveChanges();
 68:              }
 69:              catch (DbEntityValidationException dbex)
 70:              {
 71:                  var msg = string.Empty;
 72:                  foreach(var validationErrors in dbex.EntityValidationErrors)
 73:                      foreach(var validateionError in validationErrors.ValidationErrors)
 74:                          msg+=string.Format("Property:{0} Error:{1}",validateionError.PropertyName,validateionError.ErrorMessage);
 75:
 76:                  var fail = new Exception(msg,dbex);
 77:                  throw fail;
 78:              }
 79:          }
 80:
 81:          public virtual void Update(T entity)
 82:          {
 83:              try
 84:              {
 85:                  if (entity == null)
 86:                      throw new ArgumentNullException("实体类为空");
 87:                  context.SaveChanges();
 88:              }
 89:              catch (DbEntityValidationException dbex)
 90:              {
 91:                  var msg = string.Empty;
 92:                  foreach (var validationErrors in dbex.EntityValidationErrors)
 93:                      foreach (var validateionError in validationErrors.ValidationErrors)
 94:                          msg += string.Format("Property:{0} Error:{1}", validateionError.PropertyName, validateionError.ErrorMessage);
 95:
 96:                  var fail = new Exception(msg, dbex);
 97:                  throw fail;
 98:              }
 99:          }
100:
101:          public virtual void Delete(T entity)
102:          {
103:              try
104:              {
105:                  if (entity == null)
106:                      throw new ArgumentNullException("实体类为空");
107:                  DbSet.Remove(entity);
108:                  context.SaveChanges();
109:              }
110:              catch (DbEntityValidationException dbex)
111:              {
112:                  var msg = string.Empty;
113:                  foreach (var validationErrors in dbex.EntityValidationErrors)
114:                      foreach (var validateionError in validationErrors.ValidationErrors)
115:                          msg += string.Format("Property:{0} Error:{1}", validateionError.PropertyName, validateionError.ErrorMessage);
116:
117:                  var fail = new Exception(msg, dbex);
118:                  throw fail;
119:              }
120:          }
121:
122:          public virtual void Delete(Expression<Func<T, bool>> where)
123:          {
124:              try
125:              {
126:                  var entities = DbSet.Where(where);
127:                  foreach (var entity in entities.ToList())
128:                      DbSet.Remove(entity);
129:                  context.SaveChanges();
130:              }
131:              catch (DbEntityValidationException dbex)
132:              {
133:                  var msg = string.Empty;
134:                  foreach (var validationErrors in dbex.EntityValidationErrors)
135:                      foreach (var validateionError in validationErrors.ValidationErrors)
136:                          msg += string.Format("Property:{0} Error:{1}", validateionError.PropertyName, validateionError.ErrorMessage);
137:
138:                  var fail = new Exception(msg, dbex);
139:                  throw fail;
140:              }
141:          }
142:      }
143:  }

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

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

   1:  namespace TinyFrame.Data.DataUnitOfWork
   2:  {
   3:      public interface IUnitOfWork
   4:      {
   5:          void Commit();
   6:      }
   7:  }

 

 

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