【开源】OSharp框架解说系列（5.2）：EntityFramework数据层实现

阅读量：5442 次

发布时间：2019-06-15

本文共 29738 字，大约阅读时间需要 99 分钟。

OSharp是什么？

　　OSharp是个快速开发框架，但不是一个大而全的包罗万象的框架，严格的说，OSharp中什么都没有实现。与其他大而全的框架最大的不同点，就是OSharp只做抽象封装，不做实现。依赖注入、ORM、对象映射、日志、缓存等等功能，都只定义了一套最基础最通用的抽象封装，提供了一套统一的API、约定与规则，并定义了部分执行流程，主要是让项目在一定的规范下进行开发。所有的功能实现端，都是通过现有的成熟的第三方组件来实现的，除了EntityFramework之外，所有的第三方实现都可以轻松的替换成另一种第三方实现，OSharp框架正是要起隔离作用，保证这种变更不会对业务代码造成影响，使用统一的API来进行业务实现，解除与第三方实现的耦合，保持业务代码的规范与稳定。

本文已同步到系列目录：

前言

　　的数据层设计中，我们主要设计了数据对对外开放的实体基类EntityBase<TKey>，单元操作接口IUnitOfWork 和数据仓储接口IRepository<TEntity, TKey>，下面我们来解说怎样来使用 EntityFramework 对这些数据访问需求进行实现。EntityFramework 的实现中，我们不仅要实现以上设计的两个接口，还要做以下几件事：

设计一个与业务实体解耦的 EntityFramework数据上下文类

设计实体加载方案，将业务实体加载到上下文中

设计数据迁移方案，对 EntityFramework 的运行环境进行初始化

使用已初始化的上下文实现数据仓储操作

　　下面，我们将逐条进行解说。

　　代码分布图：

设计与业务解耦的上下文类

　　EntityFramework 的封装，首要目标就是与业务层，业务实体解耦。怎样才算是解耦呢？如果不解耦，通常我们使用 EntityFramework 需要定义如下这样一个上下文类的：

1 public class DemoDbContext : DbContext 2 { 3     public DbSet
     
       Organizations { get; set; } 4  5     public DbSet
      
        Roles { get; set; } 6  7     public DbSet
       
         Users { get; set; } 8  9     protected override void OnModelCreating(DbModelBuilder modelBuilder)10     {11         modelBuilder.Entity
        
         ().HasOptional(m => m.Parent).WithMany(n => n.Children);12         modelBuilder.Entity
         
          ().HasRequired(m => m.Organization).WithMany();13         modelBuilder.Entity
          
           ().HasMany(m => m.Roles).WithMany(n => n.Users);14 }15 }

　　在上面的上下文类中，业务实体与上下文类是紧耦合的，每次实体类或者实体之间的关系有变动，都要来修改这个上下文类DemoDbContext，又是无法扩展的，是典型的违反了“开闭原则”（软件系统对于组件功能的扩展是开放的，是允许对其进行功能扩展的；对于原有代码的修改是封闭的，即不应该修改原有的代码。）。所以，我们应该让 EntityFramework 的上下文与业务实体之间进行解耦，特别是对于 OSharp 这样作为开发框架存在的基础设施，解耦更是至关重要。

　　从上面的示例上下文类中得知，实体类与上下文的耦合主要发生在两个部分：

EntityFramework上下文类需拥有业务实体的 DbSet<TEntity> 类型的属性，这个属性即是业务实体加载到上下文的途径，也是进行数据操作时获取相应实体数据集DbSet<TEntity>的途径。

在上下文类的 OnModelCreating 方法中配置实体间的关系细节

　　要进行解耦，也需要从这两方面着手。OSharp 的 EntityFramework 上下文将定义为如下：

1     ///   2     /// EntityFramework-CodeFirst数据上下文  3     /// 
  4     public class CodeFirstDbContext : DbContext, IUnitOfWork, IDependency  5     {  6         ///   7         /// 初始化一个
      类型的新实例  8         /// 
  9         public CodeFirstDbContext() 10             : this(GetConnectionStringName()) 11         { } 12  13         ///  14         /// 使用连接名称或连接字符串 初始化一个
      类型的新实例 15         /// 
 16         public CodeFirstDbContext(string nameOrConnectionString) 17             : base(nameOrConnectionString) 18         { } 19  20         ///  21         /// 获取或设置 是否开启事务提交 22         /// 
 23         public bool TransactionEnabled { get; set; } 24  25         ///  26         /// 获取 数据库连接串名称 27         /// 
 28         /// 
      29         private static string GetConnectionStringName() 30         { 31             string name = ConfigurationManager.AppSettings.Get("OSharp-ConnectionStringName") 32                 ?? ConfigurationManager.AppSettings.Get("ConnectionStringName") ?? "default"; 33             return name; 34         } 35  36         ///  37         /// 提交当前单元操作的更改。 38         /// 
 39         /// 
     
      操作影响的行数
      40         public override int SaveChanges() 41         { 42             return SaveChanges(true); 43         } 44  45         ///  46         /// 提交当前单元操作的更改。 47         /// 
 48         /// 提交保存时是否验证实体约束有效性。 49         /// 
     
      操作影响的行数
      50         internal int SaveChanges(bool validateOnSaveEnabled) 51         { 52             bool isReturn = Configuration.ValidateOnSaveEnabled != validateOnSaveEnabled; 53             try 54             { 55                 Configuration.ValidateOnSaveEnabled = validateOnSaveEnabled; 56                 int count = base.SaveChanges(); 57                 TransactionEnabled = false; 58                 return count; 59             } 60             catch (DbUpdateException e) 61             { 62                 if (e.InnerException != null && e.InnerException.InnerException is SqlException) 63                 { 64                     SqlException sqlEx = e.InnerException.InnerException as SqlException; 65                     string msg = DataHelper.GetSqlExceptionMessage(sqlEx.Number); 66                     throw new OSharpException("提交数据更新时发生异常：" + msg, sqlEx); 67                 } 68                 throw; 69             } 70             finally 71             { 72                 if (isReturn) 73                 { 74                     Configuration.ValidateOnSaveEnabled = !validateOnSaveEnabled; 75                 } 76             } 77         } 78 #if NET45 79  80         #region Overrides of DbContext 81  82         ///  83         /// 异步提交当前单元操作的更改。 84         /// 
 85         /// 
     
      操作影响的行数
      86         public override Task
     
       SaveChangesAsync() 87         { 88             return SaveChangesAsync(true); 89         } 90  91         #endregion 92  93         /// 
       94         /// 提交当前单元操作的更改。 95         /// 
 96         /// 
      提交保存时是否验证实体约束有效性。 97         /// 
      
       操作影响的行数
       98         internal async Task
      
        SaveChangesAsync(bool validateOnSaveEnabled) 99         {100             bool isReturn = Configuration.ValidateOnSaveEnabled != validateOnSaveEnabled;101             try102             {103                 Configuration.ValidateOnSaveEnabled = validateOnSaveEnabled;104                 int count = await base.SaveChangesAsync();105                 TransactionEnabled = false;106                 return count;107             }108             catch (DbUpdateException e)109             {110                 if (e.InnerException != null && e.InnerException.InnerException is SqlException)111                 {112                     SqlException sqlEx = e.InnerException.InnerException as SqlException;113                     string msg = DataHelper.GetSqlExceptionMessage(sqlEx.Number);114                     throw new OSharpException("提交数据更新时发生异常：" + msg, sqlEx);115                 }116                 throw;117             }118             finally119             {120                 if (isReturn)121                 {122                     Configuration.ValidateOnSaveEnabled = !validateOnSaveEnabled;123                 }124             }125         }126 #endif127         protected override void OnModelCreating(DbModelBuilder modelBuilder)128         {129             //移除一对多的级联删除130             modelBuilder.Conventions.Remove
       
        ();131         }132     }

　　OSharp 中定义的 EntityFramework 上下文类 CodeFirstDbContext 主要做了以下几件事：

上下文类 CodeFirstDbContext 实现了 IUnitOfWork 接口（与架构系列的那个进行对比，OSharp 的 EntityFramework 的实现在架构上进行了简化）。

默认读取 Web.Config 中AppSettings中配置的名为“OSharp-ConnectionStringName”的键获取默认数据库连接串名称，进行默认上下文的实例化。

上下文在执行提交保存之后，重置 public bool TransactionEnabled { get; set; } 属性的值为 false。

在重写 OnModelCreating 方法时移除一对多的级联删除（OneToManyCascadeDeleteConvention），防止“删除一个主干实体，子实体全部自动删除”的误删除悲剧发生。如果需要级联删除，再在实体的 Fluent API 配置中单独开启。

当需要业务实体TEntity 的 DbSet<TEntity>数据集时，可以通过 DbContext 的 public virtual DbSet<TEntity> Set<TEntity>() where TEntity : class{} 方法来获取。

解耦的业务实体的加载与数据迁移

解耦的业务实体的加载

　　上述 EntityFramework 上下文进行了与业务实体的解耦，那么业务实体是怎样加载到上下文中的呢？下面我们就来解决这个问题。

　　在 EntityFramework 6 的版本中，EntityFramework 提供了两个动态加载业务实体类的途径：

加载单个实体类配置： public virtual ConfigurationRegistrar Add<TEntityType>(EntityTypeConfiguration<TEntityType> entityTypeConfiguration) where TEntityType : class{}

加载单个实体类复合配置： public virtual ConfigurationRegistrar Add<TComplexType>(ComplexTypeConfiguration<TComplexType> complexTypeConfiguration) where TComplexType : class

使用反射加载程序集中的单个实体类配置或实体类复合配置： public virtual ConfigurationRegistrar AddFromAssembly(Assembly assembly){} ，此API为 EntityFramework 6 新增的

　　在 OSharp 的业务实体加载设计中，将使用前两个加载方式。

　　首先，设计了一个专用于业务实体加载到上下文的接口：

1  ///  2  /// 实体映射接口 3  /// 
 4  public interface IEntityMapper 5  { 6      ///  7      /// 将当前实体映射对象注册到当前数据访问上下文实体映射配置注册器中 8      /// 
 9      /// 实体映射配置注册器10      void RegistTo(ConfigurationRegistrar configurations);11  }

　　分别对简单实体与复合实体实现这个接口：

1 ///  2 /// 数据实体映射配置基类 3 /// 
 4 /// 
     
      动态实体类型
      5 /// 
     
      动态主键类型
      6 public abstract class EntityConfigurationBase
     
       : EntityTypeConfiguration
      
       , IEntityMapper  7     where TEntity : EntityBase
       
         8 { 9     /// 
        10     /// 将当前实体映射对象注册到当前数据访问上下文实体映射配置注册器中11     /// 
12     /// 
        实体映射配置注册器13     public void RegistTo(ConfigurationRegistrar configurations)14     {15         configurations.Add(this);16     }17 }18 19 20 /// 
        21 /// 复合数据实体映射配置基类22 /// 
23 /// 
        
         动态复合实体类型
        24 /// 
        
         动态主键类型
        25 public abstract class ComplexTypeConfigurationBase
        
          : ComplexTypeConfiguration
         
          , IEntityMapper26     where TComplexType : EntityBase
          
           27 {28 #region Implementation of IEntityMapper29 30 /// 
           31 /// 将当前实体映射对象注册到当前数据访问上下文实体映射配置注册器中32 /// 
33 /// 
           实体映射配置注册器34 public void RegistTo(ConfigurationRegistrar configurations)35 {36 configurations.Add(this);37 }38 39 #endregion40 }

　　每个业务实体类都要实现一个映射配置，在配置中可以通过 FluentAPI 进行实体与数据库的映射细节配置（如表名，外键关系，索引等），例如：

1 public class OrganizationConfiguration : EntityConfigurationBase
     
      2 {3     public OrganizationConfiguration()4     {5         HasOptional(m => m.Parent).WithMany(n => n.Children);6     }7 }

　　关于实体与数据库的映射，通常有两种方式：DataAnnotation 与 FluentAPI，那么，什么时候使用什么方式呢？为了实保持实体类的通用性，减少第三方依赖，通常遵从如下原则：

当映射特性与 EntityFramework 无关时，使用 DataAnnotation，例如 Required、StringLength 等。

当映射特性与 EntityFramework 耦合时，使用 FluentAPI，例如 ToTable、HasForeignKey、HasMany 等。

　　在进行 EntityFramework 的初始化的时候，需要将所有实现了 IEntityMapper 接口的所有实体映射配置类的实例都初始化出来，存储在 DatabaseInitializer.EntityMappers 属性中，然后在初始化 EntityFramework 上下文的时候，将这些映射配置的实例加载到 modelBuilder.Configurations 中，即可完成 EntityFramework 上下文对业务实体的加载及映射。　　

1 protected override void OnModelCreating(DbModelBuilder modelBuilder) 2 { 3     //移除一对多的级联删除 4     modelBuilder.Conventions.Remove
     
      (); 5  6     //注册实体配置信息 7     ICollection
      
        entityMappers = DatabaseInitializer.EntityMappers; 8     foreach (IEntityMapper mapper in entityMappers) 9     {10         mapper.RegistTo(modelBuilder.Configurations);11     }12 }

数据初始化及迁移配置

种子数据初始化

　　在项目开发过程中，为了项目运行和测试的需要，往往需要在数据库创建的时候，向数据库中添加初始数据（种子数据），EntityFramework 创建数据库时是支持种子数据的初始化的。

　　在OSharp中，定义了一个专用于种子数据初始化的接口：

1  ///  2  /// 初始化种子数据接口 3  /// 
 4  public interface ISeedAction 5  { 6      ///  7      /// 获取 操作排序，数值越小越先执行 8      /// 
 9      int Order { get; }10 11      /// 12      /// 定义种子数据初始化过程13      /// 
14      /// 数据上下文15      void Action(DbContext context);16  }

　　在各个模块中，如果需要进行种子数据的初始化，需要实现这个接口，并在 Action 方法中使用上下文参数 context 实现数据的初始化：

1 public class IdentitySeedAction : ISeedAction 2 { 3     ///  4     /// 获取 操作排序，数值越小越先执行 5     /// 
 6     public int Order { get { return 0; } } 7  8     ///  9     /// 定义种子数据初始化过程10     /// 
11     /// 数据上下文12     public void Action(DbContext context)13     {14         List
     
       organizations = new List
      
       ()15         {16             new Organization(){Name = "系统", Remark = "系统根节点", },17         };18         context.Set
       
        ().AddOrUpdate(m => new { m.Name }, organizations.ToArray());19     }20 }

　　当数据库不存在时，可以使用 EntityFramework 中定义的 CreateDatabaseIfNotExists<TDbContext> 来创建数据库。OSharp 中从这个类派生了一个支持种子数据初始化的类型，来处理在创建数据库的时候初始化种子数据：

1 ///  2 /// 在数据库不存在时使用种子数据创建数据库 3 /// 
 4 public class CreateDatabaseIfNotExistsWithSeed : CreateDatabaseIfNotExists
     
       5 { 6     static CreateDatabaseIfNotExistsWithSeed() 7     { 8         SeedActions = new List
      
       (); 9     }10 11     /// 
       12     /// 获取 数据库创建时的种子数据操作信息集合，各个模块可以添加自己的初始化数据13     /// 
14     public static ICollection
       
         SeedActions { get; private set; }15 16     protected override void Seed(CodeFirstDbContext context)17     {18         IEnumerable
        
          seedActions = SeedActions.OrderBy(m => m.Order);19         foreach (ISeedAction seedAction in seedActions)20         {21             seedAction.Action(context);22         }23     }24 }

　　在 EntityFramework 初始化的时候，只需要将 ISeedAction 接口的派生类的实例添加到 SeedActions 属性中即可： CreateDatabaseIfNotExistsWithSeed.SeedActions.Add(new IdentitySeedAction());

数据迁移配置

　　OSharp 在数据迁移方面的考虑很简单，默认开启了自动迁移的迁移方式。自动迁移的启用主要涉及两个属性：

AutomaticMigrationsEnabled = true;获取或设置指示迁移数据库时是否可使用自动迁移的值。

AutomaticMigrationDataLossAllowed = true;获取或设置指示是否可接受自动迁移期间的数据丢失的值。如果设置为 false，则将在数据丢失可能作为自动迁移一部分出现时引发异常。

　　迁移配置类中同样定义了种子数据的初始化，需要注意的是：这里的种子数据与 CreateDatabaseIfNotExistsWithSeed 类中的有个不太一样的地方， CreateDatabaseIfNotExistsWithSeed 类中的种子数据，只在创建数据库的时候运行一次，而这里的，将会在每次进行迁移的时候，都会对种子数据进行还原。

1 ///  2 /// 在数据库不存在时使用种子数据创建数据库 3 /// 
 4 public class CreateDatabaseIfNotExistsWithSeed : CreateDatabaseIfNotExists
     
       5 { 6     static CreateDatabaseIfNotExistsWithSeed() 7     { 8         SeedActions = new List
      
       (); 9     }10 11     /// 
       12     /// 获取 数据库创建时的种子数据操作信息集合，各个模块可以添加自己的初始化数据13     /// 
14     public static ICollection
       
         SeedActions { get; private set; }15 16     protected override void Seed(CodeFirstDbContext context)17     {18         IEnumerable
        
          seedActions = SeedActions.OrderBy(m => m.Order);19         foreach (ISeedAction seedAction in seedActions)20         {21             seedAction.Action(context);22         }23     }24 }

EntityFramework 初始化

　　OSharp 中的 EntityFramework 数据存储运行环境的初始化，主要包含如下几个方面：

将业务实体的 EntityTypeConfiguration<TEntity> 实体映射类所在程序集加载到数据层中，并获取所有 IEntityMapper 接口的派生类的实例以备创建数据上下文 CodeFirstDbContext 实例时使用

将所有 ISeedAction 接口派生的种子数据初始化类的实例加载到相应的EntityFramework初始化策略中

设置 EntityFramework 初始化策略，当数据库不存在时，使用 CreateDatabaseIfNotExistsWithSeed 进行初始化；当数据库存在时，使用 MigrateDatabaseToLatestVersion 数据迁移策略

EntityFramework 数据库架构的预热

　　初始化的一个示例如下，在主程序入口中（例如Global的Application_Start）：

1 private static void DatabaseInitialize()2 {3     Assembly assembly = Assembly.GetExecutingAssembly();4     DatabaseInitializer.AddMapperAssembly(assembly);5     CreateDatabaseIfNotExistsWithSeed.SeedActions.Add(new IdentitySeedAction());6 7     DatabaseInitializer.Initialize();8 }

　　初始化类 DatabaseInitializer 实现如下：

1 ///  2 /// 数据库初始化操作类 3 /// 
 4 public class DatabaseInitializer 5 { 6     private static readonly ICollection
     
       MapperAssemblies = new List
      
       (); 7  8     /// 
        9     /// 获取 数据实体映射配置信息集合10     /// 
11     public static ICollection
       
         EntityMappers { get { return GetAllEntityMapper(); } }12 13     /// 
        14     /// 设置数据库初始化，策略为自动迁移到最新版本15     /// 
16     public static void Initialize()17     {18         CodeFirstDbContext context = new CodeFirstDbContext();19         IDatabaseInitializer
        
          initializer;20         if (!context.Database.Exists())21         {22             initializer = new CreateDatabaseIfNotExistsWithSeed();23         }24         else25         {26             initializer = new MigrateDatabaseToLatestVersion
         
          ();27         }28         Database.SetInitializer(initializer);29         30         //EF预热31         ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;32         StorageMappingItemCollection mappingItemCollection = (StorageMappingItemCollection)objectContext.ObjectStateManager33             .MetadataWorkspace.GetItemCollection(DataSpace.CSSpace);34         mappingItemCollection.GenerateViews(new List
          
           ());35 context.Dispose();36 }37 38 /// 
           39 /// 添加需要搜索实体映射的程序集到检索集合中40 /// 
41 public static void AddMapperAssembly(Assembly assembly)42 {43 assembly.CheckNotNull("assembly");44 if (MapperAssemblies.Any(m => m == assembly))45 {46 return;47 }48 MapperAssemblies.Add(assembly);49 }50 51 private static ICollection
           
             GetAllEntityMapper()52 {53 Type baseType = typeof(IEntityMapper);54 Type[] mapperTypes = MapperAssemblies.SelectMany(assembly => assembly.GetTypes())55 .Where(type => baseType.IsAssignableFrom(type) && type != baseType && !type.IsAbstract).ToArray();56 ICollection
            
              result = mapperTypes.Select(type => Activator.CreateInstance(type) as IEntityMapper).ToList();57 return result;58 }59 }

　　同时，数据层的核心API IUnitOfWork ， IRepository<TEntity, TKey> 的实例化，是将由 Autofac 的 IoC 组件来完成的，需要在 IoC 初始化时进行注册：

builder.RegisterGeneric(typeof(Repository<,>)).As(typeof(IRepository<,>));

Repository 仓储操作实现

　　Repository 的实现类需要一个 IUnitOfWOrk 参数，这个参数是由 IoC 组件进行注入的，并给 UnitOfWork 与 Entities 属性进行赋值。

1 ///  2 /// EntityFramework的仓储实现 3 /// 
 4 /// 
     
      实体类型
      5 /// 
     
      主键类型
      6 public class Repository
     
       : IRepository
      
        where TEntity : EntityBase
       
         7 { 8     private readonly DbSet
        
          _dbSet; 9     private readonly IUnitOfWork _unitOfWork;10 11     public Repository(IUnitOfWork unitOfWork)12     {13         _unitOfWork = unitOfWork;14         _dbSet = ((DbContext)unitOfWork).Set
         
          ();15     }16 17     /// 
          18 /// 获取 当前单元操作对象19 /// 
20     public IUnitOfWork UnitOfWork { get { return _unitOfWork; } }21 22     /// 
          23 /// 获取 当前实体类型的查询数据集24 /// 
25     public IQueryable
          
            Entities { get { return _dbSet; } }26 27 ...28 29 }

　　在操作后台进行提交保存的时候，将根据 UnitOfWork.TransactionEnabled 的值决定是否执行保存。

1         private int SaveChanges() 2         { 3             return _unitOfWork.TransactionEnabled ? 0 : _unitOfWork.SaveChanges(); 4         } 5  6 #if NET45 7  8         private async Task
     
       SaveChangesAsync() 9         {10             return _unitOfWork.TransactionEnabled ? 0 : await _unitOfWork.SaveChangesAsync();11         }12 13 #endif

操作 API 的实现，下面将分类进行解说：

普通增、改、删业务操作API

　　普通业务操作API主要是对单个或多个实体进行的单个或批量操作API：

1 ///  2 /// 插入实体 3 /// 
 4 /// 实体对象 5 /// 
     
      操作影响的行数
      6 public int Insert(TEntity entity) 7 { 8     entity.CheckNotNull("entity"); 9     _dbSet.Add(entity);10     return SaveChanges();11 }12 13 /// 14 /// 批量插入实体15 /// 
16 /// 实体对象集合17 /// 
     
      操作影响的行数
     18 public int Insert(IEnumerable
     
       entities)19 {20     entities = entities as TEntity[] ?? entities.ToArray();21     _dbSet.AddRange(entities);22     return SaveChanges();23 }24 25 /// 
      26 /// 更新实体对象27 /// 
28 /// 
      更新后的实体对象29 /// 
      
       操作影响的行数
      30 public int Update(TEntity entity)31 {32     entity.CheckNotNull("entity");33     ((DbContext)_unitOfWork).Update
      
       (entity);34     return SaveChanges();35 }36 37 /// 
       38 /// 删除实体39 /// 
40 /// 
       实体对象41 /// 
       
        操作影响的行数
       42 public int Delete(TEntity entity)43 {44     entity.CheckNotNull("entity");45     _dbSet.Remove(entity);46     return SaveChanges();47 }48 49 public virtual int Delete(TKey key)50 {51     CheckEntityKey(key, "key");52     TEntity entity = _dbSet.Find(key);53     return entity == null ? 0 : Delete(entity);54 }55 56 /// 
       57 /// 删除所有符合特定条件的实体58 /// 
59 /// 
       查询条件谓语表达式60 /// 
       
        操作影响的行数
       61 public int Delete(Expression
       
        
         > predicate)62 {63     predicate.CheckNotNull("predicate");64     TEntity[] entities = _dbSet.Where(predicate).ToArray();65     return entities.Length == 0 ? 0 : Delete(entities);66 }67 68 /// 
         69 /// 批量删除删除实体70 /// 
71 /// 
         实体对象集合72 /// 
         
          操作影响的行数
         73 public int Delete(IEnumerable
         
           entities)74 {75     entities = entities as TEntity[] ?? entities.ToArray();76     _dbSet.RemoveRange(entities);77     return SaveChanges();78 }

　　上面的 Update 更新代码，是通过一个扩展方法来完成的，这个扩展方法基本能解决在 EntityFramework 数据更新中会遇到的问题（详见架构系列的《》篇）

1 ///  2 /// 更新上下文中指定的实体的状态 3 /// 
 4 /// 
     
      实体类型
      5 /// 
     
      主键类型
      6 /// 上下文对象 7 /// 要更新的实体类型 8 public static void Update
     
      (this DbContext dbContext, params TEntity[] entities) where TEntity : EntityBase
      
        9 {10     dbContext.CheckNotNull("dbContext");11     entities.CheckNotNull("entities");12 13     foreach (TEntity entity in entities)14     {15         DbSet
       
         dbSet = dbContext.Set
        
         ();16         try17         {18             DbEntityEntry
         
           entry = dbContext.Entry(entity);19             if (entry.State == EntityState.Detached)20             {21                 dbSet.Attach(entity);22                 entry.State = EntityState.Modified;23             }24         }25         catch (InvalidOperationException)26         {27             TEntity oldEntity = dbSet.Find(entity.Id);28             dbContext.Entry(oldEntity).CurrentValues.SetValues(entity);29         }30     }31 }

针对 DTO 的增、改、删业务操作API

　　在业务层实现对实体的增加，更新操作的时候，如果业务层接收的是 Dto 数据，需要对 Dto 的数据进行合法性检查，再将 Dto 通过数据映射组件 AutoMapper 创建或更新相应类型的实体数据模型 Model，然后再按需求对 Model 的导航属性进行更新，再提交保存。在进行删除操作的时候，需要使用传入的主键 Id 检索相应的实体信息，并检查删除操作的可行性，再提交到上下文中进行删除操作，并删除其他相关数据。在这些针对实体的业务操作中，存在着很多相似的重复代码，这种重复代码的存在，会极大降低系统的可维护性。因此，在数据仓储操作中设计了一组专门针对 Dto 的业务操作API，利用无返回委托 Action<T> 与有返回委托 Func<T, RT> 来向底层传递各实体业务操作的变化点的业务逻辑，以达到对 Dto 业务重复代码的彻底重构。

1 ///   2 /// 以DTO为载体批量插入实体  3 /// 
  4 /// 
     
      添加DTO类型
       5 /// 添加DTO信息集合  6 /// 添加信息合法性检查委托  7 /// 由DTO到实体的转换委托  8 /// 
     
      业务操作结果
       9 public OperationResult Insert
     
      (ICollection
      
        dtos, Action
       
         checkAction = null, Func
        
          updateFunc = null)  10     where TAddDto : IAddDto 11 { 12     dtos.CheckNotNull("dtos"); 13     List
         
           names = new List
          
           (); 14 foreach (var dto in dtos) 15 { 16 TEntity entity = Mapper.Map
           
            (dto); 17 try 18 { 19 if (checkAction != null) 20 { 21 checkAction(dto); 22 } 23 if (updateFunc != null) 24 { 25 entity = updateFunc(dto, entity); 26 } 27 } 28 catch (Exception e) 29 { 30 return new OperationResult(OperationResultType.Error, e.Message); 31 } 32 _dbSet.Add(entity); 33 string name = GetNameValue(dto); 34 if (name != null) 35 { 36 names.Add(name); 37 } 38 } 39 int count = SaveChanges(); 40 return count > 0 41 ? new OperationResult(OperationResultType.Success, 42 names.Count > 0 43 ? "信息“{0}”添加成功".FormatWith(names.ExpandAndToString()) 44 : "{0}个信息添加成功".FormatWith(dtos.Count)) 45 : new OperationResult(OperationResultType.NoChanged); 46 } 47 48 /// 
             49 /// 以DTO为载体批量更新实体 50 /// 
 51 /// 
            
             更新DTO类型
             52 /// 
            更新DTO信息集合 53 /// 
            更新信息合法性检查委托 54 /// 
            由DTO到实体的转换委托 55 /// 
            
             业务操作结果
             56 public OperationResult Update
            
             (ICollection
             
               dtos, Action
              
                checkAction = null, Func
               
                 updateFunc = null) 57 where TEditDto : IEditDto
                
                  58 { 59 dtos.CheckNotNull("dtos" ); 60 List
                 
                   names = new List
                  
                   (); 61 foreach (var dto in dtos) 62 { 63 TEntity entity = _dbSet.Find(dto.Id); 64 if (entity == null) 65 { 66 return new OperationResult(OperationResultType.QueryNull); 67 } 68 entity = Mapper.Map(dto, entity); 69 try 70 { 71 if (checkAction != null) 72 { 73 checkAction(dto); 74 } 75 if (updateFunc != null) 76 { 77 entity = updateFunc(dto, entity); 78 } 79 } 80 catch (Exception e) 81 { 82 return new OperationResult(OperationResultType.Error, e.Message); 83 } 84 ((DbContext)_unitOfWork).Update
                   
                    (entity); 85 string name = GetNameValue(dto); 86 if (name != null) 87 { 88 names.Add(name); 89 } 90 } 91 int count = SaveChanges(); 92 return count > 0 93 ? new OperationResult(OperationResultType.Success, 94 names.Count > 0 95 ? "信息“{0}”更新成功".FormatWith(names.ExpandAndToString()) 96 : "{0}个信息更新成功".FormatWith(dtos.Count)) 97 : new OperationResult(OperationResultType.NoChanged); 98 } 99 100 /// 
                    101 /// 以标识集合批量删除实体102 /// 
103 /// 
                    标识集合104 /// 
                    删除前置检查委托105 /// 
                    删除委托，用于删除关联信息106 /// 
                    
                     业务操作结果
                    107 public OperationResult Delete(ICollection
                    
                      ids, Action
                     
                       checkAction = null, Func
                      
                        deleteFunc = null)108 {109 ids.CheckNotNull("ids" );110 List
                       
                         names = new List
                        
                         ();111 foreach (var id in ids)112 {113 TEntity entity = _dbSet.Find(id);114 try115 {116 if (checkAction != null)117 {118 checkAction(entity);119 }120 if (deleteFunc != null)121 {122 entity = deleteFunc(entity);123 }124 }125 catch (Exception e)126 {127 return new OperationResult(OperationResultType.Error, e.Message);128 }129 _dbSet.Remove(entity);130 string name = GetNameValue(entity);131 if (name != null)132 {133 names.Add(name);134 }135 }136 int count = SaveChanges();137 return count > 0138 ? new OperationResult(OperationResultType.Success,139 names.Count > 0140 ? "信息“{0}”删除成功".FormatWith(names.ExpandAndToString())141 : "{0}个信息删除成功".FormatWith(ids.Count))142 : new OperationResult(OperationResultType.NoChanged);143 }

上面的代码，使用了委托 Action ， Func<T> 来封装业务逻辑中的变化点（比如实体合法性检查，给实体的导航属性赋值等），而将公共代码提取出来下沉到底层中，这是一个很好的封装思路。

　　使用上面的封装，我们在业务实现时只需要编号非常核心的几行代码，即可完成一个业务的操作，例如：

1 ///   2 /// 添加组织机构信息信息  3 /// 
  4 /// 要添加的组织机构信息DTO信息  5 /// 
     
      业务操作结果
       6 public OperationResult AddOrganizations(params OrganizationDto[] dtos)  7 {  8     dtos.CheckNotNull("dtos");  9     List
     
       organizations = new List
      
       (); 10     OperationResult result = _organizationRepository.Insert(dtos, 11         dto => 12         { 13             if (_organizationRepository.ExistsCheck(m => m.Name == dto.Name)) 14             { 15                 throw new Exception("组织机构名称“{0}”已存在，不能重复添加。".FormatWith(dto.Name)); 16             } 17         }, 18         (dto, entity) => 19         { 20             if (dto.ParentId.HasValue && dto.ParentId.Value > 0) 21             { 22                 Organization parent = _organizationRepository.GetByKey(dto.ParentId.Value); 23                 if (parent == null) 24                 { 25                     throw new Exception("指定父组织机构不存在。"); 26                 } 27                 entity.Parent = parent; 28             } 29             organizations.Add(entity); 30             return entity; 31         }); 32     if (result.ResultType == OperationResultType.Success) 33     { 34         int[] ids = organizations.Select(m => m.Id).ToArray(); 35         RefreshOrganizationsTreePath(ids); 36     } 37     return result; 38 } 39  40 /// 
        41 /// 更新组织机构信息信息 42 /// 
 43 /// 
       包含更新信息的组织机构信息DTO信息 44 /// 
       
        业务操作结果
        45 public OperationResult EditOrganizations(params OrganizationDto[] dtos) 46 { 47     dtos.CheckNotNull("dtos"); 48     List
       
         organizations = new List
        
         (); 49     OperationResult result = _organizationRepository.Update(dtos, 50         dto => 51         { 52             if (_organizationRepository.ExistsCheck(m => m.Name == dto.Name, dto.Id)) 53             { 54                 throw new Exception("组织机构名称“{0}”已存在，不能重复添加。".FormatWith(dto.Name)); 55             } 56         }, 57         (dto, entity) => 58         { 59             if (!dto.ParentId.HasValue || dto.ParentId == 0) 60             { 61                 entity.Parent = null; 62             } 63             else if (entity.Parent != null && entity.Parent.Id != dto.ParentId) 64             { 65                 Organization parent = _organizationRepository.GetByKey(dto.Id); 66                 if (parent == null) 67                 { 68                     throw new Exception("指定父组织机构不存在。"); 69                 } 70                 entity.Parent = parent; 71             } 72             organizations.Add(entity); 73             return entity; 74         }); 75     if (result.ResultType == OperationResultType.Success) 76     { 77         int[] ids = organizations.Select(m => m.Id).ToArray(); 78         RefreshOrganizationsTreePath(ids); 79     } 80     return result; 81 } 82  83 /// 
          84 /// 删除组织机构信息信息 85 /// 
 86 /// 
         要删除的组织机构信息编号 87 /// 
         
          业务操作结果
          88 public OperationResult DeleteOrganizations(params int[] ids) 89 { 90     ids.CheckNotNull("ids"); 91     OperationResult result = _organizationRepository.Delete(ids, 92         entity => 93         { 94             if (entity.Children.Any()) 95             { 96                 throw new Exception("组织机构“{0}”的子级不为空，不能删除。".FormatWith(entity.Name)); 97             } 98         }); 99     return result;100 }

　　如上面的代码所示，只需要分别去实现 Action 与 Func，进行最核心的业务代码实现，而其他的事，底层已经完全做了，是不是很简洁

数据查询 API

　　通过IQueryable<T>查询数据源，能满足大部分数据查询的需求，但某些 EntityFramework 的特定查询需求，还是应该单独定义数据查询API，以更好的保障不丢失 EntityFramework 的数据查询自由度。在这里主要定义了通过主键查找实体、使用 Include 包含指定导航属性的数据查询API：

1 ///  2 /// 实体存在性检查 3 /// 
 4 /// 查询条件谓语表达式 5 /// 编辑的实体标识 6 /// 
     
      是否存在
      7 public bool ExistsCheck(Expression
     
      
       > predicate, TKey id = default(TKey)) 8 { 9     TKey defaultId = default(TKey);10     var entity = _dbSet.Where(predicate).Select(m => new { m.Id }).SingleOrDefault();11     bool exists = id.Equals(defaultId) ? entity != null : entity != null && entity.Id.Equals(defaultId);12     return exists;13 }14 15 /// 
       16 /// 查找指定主键的实体17 /// 
18 /// 
       实体主键19 /// 
       
        符合主键的实体，不存在时返回null
       20 public TEntity GetByKey(TKey key)21 {22     CheckEntityKey(key, "key");23     return _dbSet.Find(key);24 }25 26 /// 
       27 /// 获取贪婪加载导航属性的查询数据集28 /// 
29 /// 
       属性表达式，表示要贪婪加载的导航属性30 /// 
       
        查询数据集
       31 public IQueryable
       
         GetInclude
        
         (Expression
         
          
           > path)32 {33 path.CheckNotNull("path");34 return _dbSet.Include(path);35 }36 37 /// 
           38 /// 获取贪婪加载多个导航属性的查询数据集39 /// 
40 /// 
           要贪婪加载的导航属性名称数组41 /// 
           
            查询数据集
           42 public IQueryable
           
             GetIncludes(params string[] paths)43 {44 paths.CheckNotNull("paths");45 IQueryable
            
              source = _dbSet;46 foreach (var path in paths)47 {48 source = source.Include(path);49 }50 return source;51 }