EntityFreamWork 项目总结-白红宇

EntityFreamWork 项目总结

阅读量：5278 次

发布时间：2019-06-14

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

　　前段时间一直在忙着处理一个B2C的商城项目，未来得整理这次项目的心得，今天偶有空闲便写下这篇文章以记录整个项目的设计及自我总结。

这个项目是我综合传智播客教学基础将传统三层架构与EntityFramework进行整合，其中如有不对之处，还望各位高手指点。

　　 一、项目结构:经典三层+EF

　　首先，先说说整个项目的结构。该项目使用 Visual Studio2013+EF4.4 来进行开发，可能有同学会说，EF6都出来了，为什么还使用4.4版本？

　　　　原因一、.net4.0只支持到4.4版本，

　　　　原因二、windows 2003 只支持到 .net 4.0

　　该项目整体结构如图所示，

　　API:主要用于支持第三方扩展，比如支付和登录。

　　BLL层:业务逻辑处理层。

　　Common:公用方法封装。

　　DAL层:数据访问层。

　　DBSessionFactory:数据访问会话层，主要用于DAL和数据库之间的连接。

　　DBUtility:常规三层中ADO.Net 方式与数据库的连接。

　　Interface:封装了BLL调用DAL中的IBLL接口，及DAL中方法调用DBSession时其中的基本的CURD的方法的接口。

　　Web.UI:表现层与业务逻辑层之间调用方法的封装。

　　Web:表现层。数据来源于UI及BLL层中。

　　二、数据库主要结构　　

　　主要表结构设计为：订单模块、会员模块、商品模块、文章模块、后台管理模块和其他一些表的设计。

　　三、各个模块的功能介绍

　　　　1.DBSessionFactory模块。

　　　　DBsession主要用于数据库的交互，进行保存数据或者查询数据。

1 　　 ///  2     /// 封装的数据操作类 3     /// 
 4     public partial class DBSession 5     { 6         ///  7         /// EF上下文对象，由工厂创建 8         /// 
 9         DbContext dbContext=TDB2C.DbContextFacory.DbContextFactory.GetDbContext();10         /// 11         /// 执行特殊SQL语句或存储过程12         /// 
13         /// Sql语句或存储过程14         /// 参数数组15         /// 
     
      返回影响行数
     16         public int ExecutNoneQuery(string sql, SqlParameter[] parameters)17         {18             return dbContext.Database.ExecuteSqlCommand(sql, parameters);19         }20         /// 21         /// 执行SQL语句，返回指定类型的对象集合22         /// 
23         /// 
     24         /// 25         /// 26         /// 
     27         public List
     
       ExecutDataTable
      
       (string sql, SqlParameter[] parameters)28         {29             return dbContext.Database.SqlQuery
       
        (sql, parameters).ToList();30         }31         /// 
        32         /// 将所有操作一次性保存会数据库，避免频繁连接和操作数据库33         /// 
34         /// 
        35         public int SaveChanges()36         {37             try38             {39                 return dbContext.SaveChanges();40             }41             catch(Exception ex)42             {43                 TDB2C.Common.LogHelper.LogFatal(ex.Message, ex);44                 throw ex;45             }46         }47     }

　　　　AbstructFacotry.tt 主要用于反射出 DAL对象与DBSession层之间的 IDAL 对象。

　　2.Interface中两个接口。

　　IDAL 接口: 将数据库中的常用方法进行抽象。具体实现交给DAL层来完成。

1  public interface IBaseDAL
      
        where T:class,new()  2     {  3         /// 
         4         /// 根据条件，获取当个对象，带排序  5         /// 
  6         T LoadEntity(Expression
       
        
         > whereLambda, params OrderModelField[] orderByExpression);  7         /// 
           8         /// 获取满足条件的所有数据  9         /// 
 10         IQueryable
         
           LoadEntities(Expression
          
           
            > whereLambda, params OrderModelField[] orderByExpression); 11 /// 
             12 /// 获取前几条数据，根据条件，排序条件，数量 13 /// 
 14 IQueryable
            
              LoadEntities(int top, Expression
             
              
               > whereLambda, params OrderModelField[] orderByExpression); 15 /// 
                16 /// 获取分页数据，根据过滤条件，排序条件，页码，页容量， 17 /// 
 18 IQueryable
               
                 LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression
                
                 
                  > whereLambda, params OrderModelField[] orderByExpression); 19 /// 
                   20 /// 增加新实体 21 /// 
 22 T AddEntity(T entity); 23 /// 
                   24 /// 删除该实体 25 /// 
 26 void DeleteEntity(T entity); 27 /// 
                   28 /// 修改实体 29 /// 
 30 void UpdateEntity(T entity); 31 32 #region 聚合函数 33 /// 
                   34 /// 统计合计,若统计字段中包含null值，则不计入运算结果 35 /// 
 36 /// 
                  过滤条件 Lambda表达式 37 /// 
                  选择字段的 Lambda表达式 38 /// 
                  
                   返回合计值
                   39 int? GetSum(Expression
                  
                   
                    > whereLambda, Expression
                    
                     
                      > fieldLambda); 40 /// 
                       41 /// 统计合计,若统计字段中包含null值，则不计入运算结果 42 /// 
 43 /// 
                      过滤条件 Lambda表达式 44 /// 
                      选择字段的 Lambda表达式 45 /// 
                      
                       返回合计值
                       46 decimal? GetSum(Expression
                      
                       
                        > whereLambda, Expression
                        
                         
                          > fieldLambda); 47 /// 
                           48 /// 获得最大值,若统计字段中包含null值，则不计入运算结果 49 /// 
 50 /// 
                          过滤条件 Lambda表达式 51 /// 
                          选择字段的 Lambda表达式 52 /// 
                          
                           返回最大值
                           53 int? GetMax(Expression
                          
                           
                            > whereLambda, Expression
                            
                             
                              > fieldLambda); 54 /// 
                               55 /// 获得最大值,若统计字段中包含null值，则不计入运算结果 56 /// 
 57 /// 
                              过滤条件 Lambda表达式 58 /// 
                              选择字段的 Lambda表达式 59 /// 
                              
                               返回最大值
                               60 decimal? GetMax(Expression
                              
                               
                                > whereLambda, Expression
                                
                                 
                                  > fieldLambda); 61 /// 
                                   62 /// 获得最小值,若统计字段中包含null值，则不计入运算结果 63 /// 
 64 /// 
                                  过滤条件 Lambda表达式 65 /// 
                                  选择字段的 Lambda表达式 66 /// 
                                  
                                   返回最小值
                                   67 int? GetMin(Expression
                                  
                                   
                                    > whereLambda, Expression
                                    
                                     
                                      > fieldLambda); 68 /// 
                                       69 /// 获得最小值,若统计字段中包含null值，则不计入运算结果 70 /// 
 71 /// 
                                      过滤条件 Lambda表达式 72 /// 
                                      选择字段的 Lambda表达式 73 /// 
                                      
                                       返回最小值
                                       74 decimal? GetMin(Expression
                                      
                                       
                                        > whereLambda, Expression
                                        
                                         
                                          > fieldLambda); 75 /// 
                                           76 /// 获得平均值,若统计字段中包含null值，则不计入运算结果 77 /// 
 78 /// 
                                          过滤条件 Lambda表达式 79 /// 
                                          选择字段的 Lambda表达式 80 /// 
                                          
                                           返回平均值
                                           81 int? GetAverage(Expression
                                          
                                           
                                            > whereLambda, Expression
                                            
                                             
                                              > fieldLambda); 82 /// 
                                               83 /// 获得平均值,若统计字段中包含null值，则不计入运算结果 84 /// 
 85 /// 
                                              过滤条件 Lambda表达式 86 /// 
                                              选择字段的 Lambda表达式 87 /// 
                                              
                                               返回平均值
                                               88 decimal? GetAverage(Expression
                                              
                                               
                                                > whereLambda, Expression
                                                
                                                 
                                                  > fieldLambda); 89 90 91 92 /// 
                                                   93 /// 统计合计,若统计字段中包含null值，则抛异常 94 /// 
 95 /// 
                                                  过滤条件 Lambda表达式 96 /// 
                                                  选择字段的 Lambda表达式 97 /// 
                                                  
                                                   返回合计值
                                                   98 int GetSum(Expression
                                                  
                                                   
                                                    > whereLambda, Expression
                                                    
                                                     
                                                      > fieldLambda); 99 /// 
                                                      100 /// 统计合计,若统计字段中包含null值，则抛异常101 /// 
102 /// 
                                                      过滤条件 Lambda表达式103 /// 
                                                      选择字段的 Lambda表达式104 /// 
                                                      
                                                       返回合计值
                                                      105 decimal GetSum(Expression
                                                      
                                                       
                                                        > whereLambda, Expression
                                                        
                                                         
                                                          > fieldLambda);106 /// 
                                                          107 /// 获得最大值,若统计字段中包含null值，则抛异常108 /// 
109 /// 
                                                          过滤条件 Lambda表达式110 /// 
                                                          选择字段的 Lambda表达式111 /// 
                                                          
                                                           返回最大值
                                                          112 int GetMax(Expression
                                                          
                                                           
                                                            > whereLambda, Expression
                                                            
                                                             
                                                              > fieldLambda);113 /// 
                                                              114 /// 获得最大值,若统计字段中包含null值，则抛异常115 /// 
116 /// 
                                                              过滤条件 Lambda表达式117 /// 
                                                              选择字段的 Lambda表达式118 /// 
                                                              
                                                               返回最大值
                                                              119 decimal GetMax(Expression
                                                              
                                                               
                                                                > whereLambda, Expression
                                                                
                                                                 
                                                                  > fieldLambda);120 /// 
                                                                  121 /// 获得最小值,若统计字段中包含null值，则抛异常122 /// 
123 /// 
                                                                  过滤条件 Lambda表达式124 /// 
                                                                  选择字段的 Lambda表达式125 /// 
                                                                  
                                                                   返回最小值
                                                                  126 int GetMin(Expression
                                                                  
                                                                   
                                                                    > whereLambda, Expression
                                                                    
                                                                     
                                                                      > fieldLambda);127 /// 
                                                                      128 /// 获得最小值,若统计字段中包含null值，则抛异常129 /// 
130 /// 
                                                                      过滤条件 Lambda表达式131 /// 
                                                                      选择字段的 Lambda表达式132 /// 
                                                                      
                                                                       返回最小值
                                                                      133 decimal GetMin(Expression
                                                                      
                                                                       
                                                                        > whereLambda, Expression
                                                                        
                                                                         
                                                                          > fieldLambda);134 /// 
                                                                          135 /// 获得平均值,若统计字段中包含null值，则抛异常136 /// 
137 /// 
                                                                          过滤条件 Lambda表达式138 /// 
                                                                          选择字段的 Lambda表达式139 /// 
                                                                          
                                                                           返回平均值
                                                                          140 int GetAverage(Expression
                                                                          
                                                                           
                                                                            > whereLambda, Expression
                                                                            
                                                                             
                                                                              > fieldLambda);141 /// 
                                                                              142 /// 获得平均值,若统计字段中包含null值，则抛异常143 /// 
144 /// 
                                                                              过滤条件 Lambda表达式145 /// 
                                                                              选择字段的 Lambda表达式146 /// 
                                                                              
                                                                               返回平均值
                                                                              147 decimal GetAverage(Expression
                                                                              
                                                                               
                                                                                > whereLambda, Expression
                                                                                
                                                                                 
                                                                                  > fieldLambda);148 149 150 151 152 /// 
                                                                                  153 /// 获得指定条件统计结果154 /// 
155 /// 
                                                                                  过滤条件 Lambda表达式156 /// 
                                                                                  157 int GetCount(Expression
                                                                                  
                                                                                   
                                                                                    > whereLambda);158 159 #endregion160 161 /// 
                                                                                    162 /// 查找是否存在163 /// 
164 bool ExistsEntity(Expression
                                                                                    
                                                                                     
                                                                                      > whereLabmda);165 /// 
                                                                                      166 /// 查找是否存在167 /// 
168 bool ExistsEntity(int id);169 }

View Code

　　IBLL接口: 将IDAL中的方法进行扩充，然后交给BLL中去具体实现。

1     ///   2     /// 业务逻辑接口层（Business Logic Layer InterFace）,供表现层和业务逻辑层使用  3     /// 
  4     /// 
        5     public interface IBaseBLL
      
        where T:class,new()  6     {  7   8         /// 
         9         /// 获取指定对象,根据主键Id  10         /// 
 11         /// 
       主键 12         /// 
       
        获取到的对象,不存在则为Null
        13         T LoadEntity(int id); 14         /// 
        15         /// 获取指定对象,根据过滤条件字符串 16         /// 
 17         /// 
       过滤条件 where条件字符串 18         /// 
       
        获取到的对象,不存在则为Null
        19         T LoadEntity(string strWhere); 20         /// 
        21         /// 获取指定对象,根据过滤条件字符串,带排序 22         /// 
 23         /// 
       过滤条件 where条件字符串 24         /// 
       排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者"" 25         /// 
       
        获取到的对象,不存在则为Null
        26         T LoadEntity(string strWhere, string fieldOrder); 27         /// 
        28         /// 获取指定对象,根据过滤条件Lambda表达式 29         /// 
 30         /// 
       过滤条件 Lambda表达式 31         /// 
       
        获取到的对象,不存在则为Null
        32         T LoadEntity(Expression
       
        
         > whereLambda); 33         /// 
          34         /// 获取指定对象,根据过滤条件Lambda表达式,带排序 35         /// 
 36         /// 
         过滤条件 Lambda表达式 37         /// 
         排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者"" 38         /// 
         
          获取到的对象,不存在则为Null
          39         T LoadEntity(Expression
         
          
           > whereLambda, string fieldOrder); 40  41         /// 
            42 /// 获取对象集合,根据过滤条件字符串 43 /// 
 44         /// 
           过滤条件 where条件字符串 45         /// 
           
            获取到的对象集合,不存在则为new List()
            46         List
           
             LoadEntities(string strWhere); 47 /// 
             48 /// 获取对象集合,根据过滤条件字符串,带排序 49 /// 
 50 /// 
            过滤条件 where条件字符串 51 /// 
            排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者"" 52 /// 
            
             获取到的对象集合,不存在则为new List()
             53 List
            
              LoadEntities(string strWhere, string fieldOrder); 54 55 /// 
              56 /// 获取对象集合,根据过滤条件Lambda表达式 57 /// 
 58 /// 
             过滤条件 Lambda表达式 59 /// 
             
              获取到的对象集合,不存在则为new List()
              60 List
             
               LoadEntities(Expression
              
               
                > whereLambda); 61 /// 
                 62 /// 获取对象集合,根据过滤条件Lambda表达式,带排序 63 /// 
 64 /// 
                过滤条件 Lambda表达式 65 /// 
                排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者"" 66 /// 
                
                 获取到的对象集合,不存在则为new List()
                 67 List
                
                  LoadEntities(Expression
                 
                  
                   > whereLambda, string fieldOrder); 68 69 /// 
                    70 /// 获取前几条对象集合,根据过滤条件字符串 71 /// 
 72 /// 
                   指定记录数 73 /// 
                   过滤条件 where条件字符串 74 /// 
                   
                    获取到的对象集合,不存在则为new List()
                    75 List
                   
                     LoadEntities(int top, string strWhere); 76 /// 
                     77 /// 获取前几条对象集合,根据过滤条件字符串,带排序 78 /// 
 79 /// 
                    指定记录数 80 /// 
                    过滤条件 where条件字符串 81 /// 
                    排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者"" 82 /// 
                    
                     获取到的对象集合,不存在则为new List()
                     83 List
                    
                      LoadEntities(int top, string strWhere, string fieldOrder); 84 85 /// 
                      86 /// 获取前几条对象集合,根据过滤条件Lambda表达式 87 /// 
 88 /// 
                     指定记录数 89 /// 
                     过滤条件 Lambda表达式 90 /// 
                     
                      获取到的对象集合,不存在则为new List()
                      91 List
                     
                       LoadEntities(int top, Expression
                      
                       
                        > whereLambda); 92 /// 
                         93 /// 获取前几条对象集合,根据过滤条件Lambda表达式,带排序 94 /// 
 95 /// 
                        指定记录数 96 /// 
                        过滤条件 Lambda表达式 97 /// 
                        排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者"" 98 /// 
                        
                         获取到的对象集合,不存在则为new List()
                         99 List
                        
                          LoadEntities(int top, Expression
                         
                          
                           > whereLambda, string fieldOrder);100 101 /// 
                           102 /// 获取分页对象集合,根据过滤条件字符串103 /// 
104 /// 
                           当前页码105 /// 
                           页容量106 /// 
                           总记录数107 /// 
                           过滤条件 where条件字符串108 /// 
                           
                            获取到的对象集合,不存在则为new List()
                           109 List
                           
                             LoadEntities(int pageIndex, int pageSize, out int totalCount, string strWhere);110 /// 
                            111 /// 获取分页对象集合,根据过滤条件字符串，带排序112 /// 
113 /// 
                            当前页码114 /// 
                            页容量115 /// 
                            总记录数116 /// 
                            过滤条件 where条件字符串117 /// 
                            排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""118 /// 
                            
                             获取到的对象集合,不存在则为new List()
                            119 List
                            
                              LoadEntities(int pageIndex, int pageSize, out int totalCount, string strWhere, string fieldOrder);120 121 /// 
                             122 /// 获取分页对象集合,根据过滤条件Lambda表达式123 /// 
124 /// 
                             当前页码125 /// 
                             页容量126 /// 
                             总记录数127 /// 
                             过滤条件 Lambda表达式128 /// 
                             
                              获取到的对象集合,不存在则为new List()
                             129 List
                             
                               LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression
                              
                               
                                > whereLambda);130 /// 
                                131 /// 获取分页对象集合,根据过滤条件Lambda表达式，带排序132 /// 
133 /// 
                                当前页码134 /// 
                                页容量135 /// 
                                总记录数136 /// 
                                过滤条件 Lambda表达式137 /// 
                                排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""138 /// 
                                
                                 获取到的对象集合,不存在则为new List()
                                139 List
                                
                                  LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression
                                 
                                  
                                   > whereLambda, string fieldOrder);140 141 142 /// 
                                   143 /// 添加新实体，返回刚添加的实体144 /// 
145 /// 
                                   要添加的实体146 /// 
                                   
                                    返回的添加成功后的实体
                                   147 T AddEntity(T entity);148 /// 
                                   149 /// 添加实体，返回添加成功的实体及成功数量150 /// 
151 /// 
                                   要添加的实体152 /// 
                                   成功记录数153 /// 
                                   
                                    返回添加成功后的实体
                                   154 T AddEntity(T entity, out int changes);155 /// 
                                   156 /// 添加实体，返回添加成功的数量157 /// 
158 /// 
                                   要添加的实体159 /// 
                                   
                                    添加成功的数量
                                   160 int AddEntityChanges(T entity);161 162 /// 
                                   163 /// 更新实体，返回是否成功164 /// 
165 /// 
                                   要更新的实体166 /// 
                                   
                                    成功状态 true为成功,false为失败
                                   167 bool UpdateEntity(T entity);168 169 /// 
                                   170 /// 查找是否存在171 /// 
172 /// 
                                   过滤条件 Lambda表达式173 /// 
                                   
                                    存在状态 true为存在,false为不存在
                                   174 bool ExistsEntity(Expression
                                   
                                    
                                     > whereLabmda);175 /// 
                                     176 /// 查找是否存在177 /// 
178 /// 
                                     过滤条件 where条件字符串179 /// 
                                     
                                      存在状态 true为存在,false为不存在
                                     180 bool ExistsEntity(string strWhere);181 /// 
                                     182 /// 查找是否存在183 /// 
184 /// 
                                     对象主键Id185 /// 
                                     
                                      存在状态 true为存在,false为不存在
                                     186 bool ExistsEntity(int id);187 188 /// 
                                     189 /// 修改指定对象的（一个或多个）字段值190 /// 
191 /// 
                                     主键Id192 /// 
                                     字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"193 /// 
                                     
                                      返回成功状态 true为成功,false为失败
                                     194 bool UpdateFieldsEntity(int id, string strValue);195 /// 
                                     196 /// 修改满足条件的所有对象的（一个或多个）字段值197 /// 
198 /// 
                                     过滤条件 Lambda表达式199 /// 
                                     字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"200 /// 
                                     
                                      返回成功状态 true为成功,false为失败
                                     201 bool UpdateFieldsEntity(Expression
                                     
                                      
                                       > whereLambda, string strValue);202 /// 
                                       203 /// 根据条件，修改满足条件的所以的对象的（一个或多个）字段值204 /// 
205 /// 
                                       过滤条件 where条件字符串206 /// 
                                       字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"207 /// 
                                       
                                        返回成功状态 true为成功,false为失败
                                       208 bool UpdateFieldsEntity(string strWhere, string strValue);209 210 /// 
                                       211 /// 软删除实体212 /// 
213 /// 
                                       主键Id214 /// 
                                       
                                        返回成功状态 true为成功,false为失败
                                       215 bool DeleteSoftEntity(int id);216 /// 
                                       217 /// 软删除实体，删除满足Lambda条件的实体对象218 /// 
219 /// 
                                       过滤条件 Lambda表达式220 /// 
                                       
                                        返回成功状态 true为成功,false为失败
                                       221 bool DeleteSoftEntity(Expression
                                       
                                        
                                         > whereLambda);222 /// 
                                         223 /// 软删除实体，删除满足条件的实体对象224 /// 
225 /// 
                                         过滤条件 where条件字符串226 /// 
                                         
                                          返回成功状态 true为成功,false为失败
                                         227 bool DeleteSoftEntity(string strWhere);228 229 /// 
                                         230 /// 真删除实体231 /// 
232 /// 
                                         主键Id233 /// 
                                         
                                          返回成功状态 true为成功,false为失败
                                         234 bool DeleteEntity(int id);235 /// 
                                         236 /// 真删除实体，删除满足Lambda条件的实体对象237 /// 
238 /// 
                                         过滤条件 Lambda表达式239 /// 
                                         
                                          返回成功状态 true为成功,false为失败
                                         240 bool DeleteEntity(Expression
                                         
                                          
                                           > whereLambda);241 /// 
                                           242 /// 真删除实体，返回是否成功243 /// 
244 /// 
                                           要删除的实体245 /// 
                                           
                                            成功状态 true为成功,false为失败
                                           246 bool DeleteEntity(T entity);247 /// 
                                           248 /// 真删除实体，返回是否成功249 /// 
250 /// 
                                           过滤条件 where条件字符串251 /// 
                                           
                                            成功状态 true为成功,false为失败
                                           252 bool DeleteEntity(string strWhere);253 #region 聚合函数254 255 /// 
                                           256 /// 统计合计,若统计字段中包含null值，则不计入运算结果257 /// 
258 /// 
                                           过滤条件 Lambda表达式259 /// 
                                           选择字段的 Lambda表达式260 /// 
                                           
                                            返回合计值
                                           261 int? GetSum(Expression
                                           
                                            
                                             > whereLambda, Expression
                                             
                                              
                                               > fieldLambda);262 /// 
                                               263 /// 统计合计,若统计字段中包含null值，则不计入运算结果264 /// 
265 /// 
                                               过滤条件 Lambda表达式266 /// 
                                               选择字段的 Lambda表达式267 /// 
                                               
                                                返回合计值
                                               268 decimal? GetSum(Expression
                                               
                                                
                                                 > whereLambda, Expression
                                                 
                                                  
                                                   > fieldLambda);269 /// 
                                                   270 /// 获得最大值,若统计字段中包含null值，则不计入运算结果271 /// 
272 /// 
                                                   过滤条件 Lambda表达式273 /// 
                                                   选择字段的 Lambda表达式274 /// 
                                                   
                                                    返回最大值
                                                   275 int? GetMax(Expression
                                                   
                                                    
                                                     > whereLambda, Expression
                                                     
                                                      
                                                       > fieldLambda);276 /// 
                                                       277 /// 获得最大值,若统计字段中包含null值，则不计入运算结果278 /// 
279 /// 
                                                       过滤条件 Lambda表达式280 /// 
                                                       选择字段的 Lambda表达式281 /// 
                                                       
                                                        返回最大值
                                                       282 decimal? GetMax(Expression
                                                       
                                                        
                                                         > whereLambda, Expression
                                                         
                                                          
                                                           > fieldLambda);283 /// 
                                                           284 /// 获得最小值,若统计字段中包含null值，则不计入运算结果285 /// 
286 /// 
                                                           过滤条件 Lambda表达式287 /// 
                                                           选择字段的 Lambda表达式288 /// 
                                                           
                                                            返回最小值
                                                           289 int? GetMin(Expression
                                                           
                                                            
                                                             > whereLambda, Expression
                                                             
                                                              
                                                               > fieldLambda);290 /// 
                                                               291 /// 获得最小值,若统计字段中包含null值，则不计入运算结果292 /// 
293 /// 
                                                               过滤条件 Lambda表达式294 /// 
                                                               选择字段的 Lambda表达式295 /// 
                                                               
                                                                返回最小值
                                                               296 decimal? GetMin(Expression
                                                               
                                                                
                                                                 > whereLambda, Expression
                                                                 
                                                                  
                                                                   > fieldLambda);297 /// 
                                                                   298 /// 获得平均值,若统计字段中包含null值，则不计入运算结果299 /// 
300 /// 
                                                                   过滤条件 Lambda表达式301 /// 
                                                                   选择字段的 Lambda表达式302 /// 
                                                                   
                                                                    返回平均值
                                                                   303 int? GetAverage(Expression
                                                                   
                                                                    
                                                                     > whereLambda, Expression
                                                                     
                                                                      
                                                                       > fieldLambda);304 /// 
                                                                       305 /// 获得平均值,若统计字段中包含null值，则不计入运算结果306 /// 
307 /// 
                                                                       过滤条件 Lambda表达式308 /// 
                                                                       选择字段的 Lambda表达式309 /// 
                                                                       
                                                                        返回平均值
                                                                       310 decimal? GetAverage(Expression
                                                                       
                                                                        
                                                                         > whereLambda, Expression
                                                                         
                                                                          
                                                                           > fieldLambda);311 312 313 /// 
                                                                           314 /// 统计合计,若统计字段中包含null值，则抛异常315 /// 
316 /// 
                                                                           过滤条件 Lambda表达式317 /// 
                                                                           选择字段的 Lambda表达式318 /// 
                                                                           
                                                                            返回合计值
                                                                           319 int GetSum(Expression
                                                                           
                                                                            
                                                                             > whereLambda, Expression
                                                                             
                                                                              
                                                                               > fieldLambda);320 /// 
                                                                               321 /// 统计合计,若统计字段中包含null值，则抛异常322 /// 
323 /// 
                                                                               过滤条件 Lambda表达式324 /// 
                                                                               选择字段的 Lambda表达式325 /// 
                                                                               
                                                                                返回合计值
                                                                               326 decimal GetSum(Expression
                                                                               
                                                                                
                                                                                 > whereLambda, Expression
                                                                                 
                                                                                  
                                                                                   > fieldLambda);327 /// 
                                                                                   328 /// 获得最大值,若统计字段中包含null值，则抛异常329 /// 
330 /// 
                                                                                   过滤条件 Lambda表达式331 /// 
                                                                                   选择字段的 Lambda表达式332 /// 
                                                                                   
                                                                                    返回最大值
                                                                                   333 int GetMax(Expression
                                                                                   
                                                                                    
                                                                                     > whereLambda, Expression
                                                                                     
                                                                                      
                                                                                       > fieldLambda);334 /// 
                                                                                       335 /// 获得最大值,若统计字段中包含null值，则抛异常336 /// 
337 /// 
                                                                                       过滤条件 Lambda表达式338 /// 
                                                                                       选择字段的 Lambda表达式339 /// 
                                                                                       
                                                                                        返回最大值
                                                                                       340 decimal GetMax(Expression
                                                                                       
                                                                                        
                                                                                         > whereLambda, Expression
                                                                                         
                                                                                          
                                                                                           > fieldLambda);341 /// 
                                                                                           342 /// 获得最小值,若统计字段中包含null值，则抛异常343 /// 
344 /// 
                                                                                           过滤条件 Lambda表达式345 /// 
                                                                                           选择字段的 Lambda表达式346 /// 
                                                                                           
                                                                                            返回最小值
                                                                                           347 int GetMin(Expression
                                                                                           
                                                                                            
                                                                                             > whereLambda, Expression
                                                                                             
                                                                                              
                                                                                               > fieldLambda);348 /// 
                                                                                               349 /// 获得最小值,若统计字段中包含null值，则抛异常350 /// 
351 /// 
                                                                                               过滤条件 Lambda表达式352 /// 
                                                                                               选择字段的 Lambda表达式353 /// 
                                                                                               
                                                                                                返回最小值
                                                                                               354 decimal GetMin(Expression
                                                                                               
                                                                                                
                                                                                                 > whereLambda, Expression
                                                                                                 
                                                                                                  
                                                                                                   > fieldLambda);355 /// 
                                                                                                   356 /// 获得平均值,若统计字段中包含null值，则抛异常357 /// 
358 /// 
                                                                                                   过滤条件 Lambda表达式359 /// 
                                                                                                   选择字段的 Lambda表达式360 /// 
                                                                                                   
                                                                                                    返回平均值
                                                                                                   361 int GetAverage(Expression
                                                                                                   
                                                                                                    
                                                                                                     > whereLambda, Expression
                                                                                                     
                                                                                                      
                                                                                                       > fieldLambda);362 /// 
                                                                                                       363 /// 获得平均值,若统计字段中包含null值，则抛异常364 /// 
365 /// 
                                                                                                       过滤条件 Lambda表达式366 /// 
                                                                                                       选择字段的 Lambda表达式367 /// 
                                                                                                       
                                                                                                        返回平均值
                                                                                                       368 decimal GetAverage(Expression
                                                                                                       
                                                                                                        
                                                                                                         > whereLambda, Expression
                                                                                                         
                                                                                                          
                                                                                                           > fieldLambda);369 /// 
                                                                                                           370 /// 根据条件获得记录数371 /// 
372 /// 
                                                                                                           过滤条件 Lambda表达式373 /// 
                                                                                                           
                                                                                                            记录数
                                                                                                           374 int GetCount(Expression
                                                                                                           
                                                                                                            
                                                                                                             > whereLambda);375 /// 
                                                                                                             376 /// 根据条件获得记录数377 /// 
378 /// 
                                                                                                             过滤条件 where字符串379 /// 
                                                                                                             
                                                                                                              记录数
                                                                                                             380 int GetCount(string strWhere);381 #endregion382 }

View Code

　　3.DAL层

　　DAL层中，定义了泛型约束的基类，所有的Model 继承BaseDAL，里面显示实现了所有的IDAL，具体实现就不贴出来了。

1 public class BaseDAL
     
       where T:class,new()2 {3 　　//代码的具体实现...4 }

　　4.同样的BLL层中也是定义相同的泛型约束基类，所有的Model继承BaseBLL，显示实现所有IBLL中定义的方法。

1 public class BaseBLL
     
       where T:class,new()2 {3  　//代码的具体实现...4 }

　　四、总结

　　这次的项目EntityFrameWork的使用方式依然是 DBFirst模式，在数据库中建立表结构之后，生成对应的Model，这里我将原始的T4文件进行了修改，支持将数据库中表名称，字段备注说明，一并生成到Model中，如：

1     ///  2     /// 商品评论参数 标签表 3     /// 
 4     [Serializable] 5     public partial class Product_comment_merit:IModel 6     { 7        public Product_comment_merit() 8         { 9             this.Id=0;10                    this.Product_category_ids="";11                    this.Title="";12                    this.Sort_id=0;13                    this.Add_time=DateTime.Now;14                    this.Is_del=0;15                }16     17         /// 18         /// 主键Id19         /// 
20         public int Id { get; set; }21         /// 22         /// 所属分类23         /// 
24         public string Product_category_ids { get; set; }25         /// 26         /// 标题27         /// 
28         public string Title { get; set; }29         /// 30         /// 排序31         /// 
32         public int Sort_id { get; set; }33         /// 34         /// 添加时间35         /// 
36         public DateTime Add_time { get; set; }37         /// 38         /// 删除标识39         /// 
40         public int Is_del { get; set; }41     }

　　model.tt文件，将数据库中的关系，映射成C#中的model，并保留字段备注，表说明。

　　所有BLL中的类，都继承了BaseBLL，所以每一个业务逻辑都有IBLL中的 52个方法，这些方法基本涵盖了所有常规的数据操作。

　　自己所特有的业务逻辑在单独编写，因为T4模版生成出来的Class 都是partial 的。

　　整体实现的功能为, 新建立某个关系模型，重新运行T4模版文件，则就拥有了该对象的 IBLL中的 52个常用 CRUD的方法。

转载于:https://www.cnblogs.com/sandunban/p/5223334.html

你可能感兴趣的文章