Entity Framework泛型封装

简介:

Entity Framework本身的增删改查其实 已经很方便了,不过做项目的时候用的多了也就觉得有点累了,每个业务实体基本上都涉及到到了增删改查这四个基本的要素,至于封装每个公司可能都不一样,接口,设计模式都用的眼花缭乱,我闲来没事就搞个简单的封装Helper,Github上也有关于EF的扩展Libray,具体没有用过,公司的有自己的封装,自己也没怎么弄,具体地址:https://github.com/loresoft/EntityFramework.Extended.

首先来看段代码,model和context是从数据中直接生成,你可以选择自己习惯的方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//新增
   User addUser =  new  User();
   addUser.PersonID =  3 ;
   addUser.UserName =  "keso" ;
   dbContext.Entry<User>(addUser).State = EntityState.Added;
   dbContext.SaveChanges();
   //修改
   User updateUser =  new  User();
   dbContext.Users.Where(item => item.ID ==  2 ).OrderBy(item => item.ID);
   updateUser.UserName = updateUser.UserName +  "测试" ;
   dbContext.Entry<User>(updateUser).State = EntityState.Modified;
   dbContext.SaveChanges();
   //删除
   User delUser = dbContext.Users.Where(item => item.ID ==  2 ).First();
   dbContext.Entry<User>(delUser).State = EntityState.Deleted;
   dbContext.SaveChanges();

 如果每个业务实体都这么写一遍,估计公司水准有待提高,而且开发的也该跳起来骂人,本人只是简单封装下新建一个EFHelper,实际开发会封装的更多,不过底层处理是不变的

1
2
3
4
class  EFHelpler<T> where T :  class
    {
        //...
    }       

 新增

方法:

1
2
3
4
5
6
7
8
9
10
11
12
/// <summary>
       /// 实体新增
       /// </summary>
       /// <param name="model"></param>
       public  void  add(params T[] paramList)
       {
           foreach (var model in paramList)
           {
               dbContext.Entry<T>(model).State = EntityState.Added;
           }
           dbContext.SaveChanges();
       }

 调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
EFHelpler<User> helper =  new  EFHelpler<User>();
          BaseContext dbContext =  new  BaseContext();
          //新增
          List<User> listUser =  new  List<User>();
          for  ( int  i =  0 ; i <  2 ; i++)
          {
              User user =  new  User();
              user.PersonID = i;
              user.UserName =  "FlyElehant"  + i;
              listUser.Add(user);
          }
          helper.add(listUser.ToArray());
          Console.WriteLine( "新增成功" );

 查询

查询分了两种,一种是简单的查询,一种是分页的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/// <summary>
      /// 实体查询
      /// </summary>
      public  IEnumerable<T> getSearchList(System.Linq.Expressions.Expression<Func<T, bool>> where)
      {
          return  dbContext.Set<T>().Where(where);
      }
      /// <summary>
      /// 实体分页查询
      /// </summary>
      /// <typeparam name="TKey"></typeparam>
      /// <param name="where"></param>
      /// <param name="orderBy"></param>
      /// <param name="pageSize"></param>
      /// <param name="pageIndex"></param>
      /// <returns></returns>
      public  IEnumerable<T> getSearchListByPage<TKey>(Expression<Func<T, bool>> where, Expression<Func<T, TKey>> orderBy,  int  pageSize,  int  pageIndex)
      {
          return  dbContext.Set<T>().Where(where).OrderByDescending(orderBy).Skip((pageIndex -  1 ) * pageSize).Take(pageSize);
      }

 简单调用,第二个方式除了分页之外,主要是查询的时候指定一定OrderBy的类型,也就是TKey:

1
2
3
4
5
6
7
var query = helper.getSearchList(item => item.UserName.Contains( "keso" ));
        var queryMulti = helper.getSearchListByPage< int >(item => item.UserName.Contains( "FlyElehant" ), order => order.PersonID,  2 1 );
        query = queryMulti;
        foreach (User user in query)
        {
            Console.WriteLine(user.UserName);
        }

 修改

修改代码稍微读了几行,主要是用到了一下反射:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/// <summary>
     /// 按照条件修改数据
     /// </summary>
     /// <param name="where"></param>
     /// <param name="dic"></param>
     public  void  update(Expression<Func<T, bool>> where, Dictionary<string, object> dic)
     {
         IEnumerable<T> result = dbContext.Set<T>().Where(where).ToList();
         Type type = typeof(T);
         List<PropertyInfo> propertyList = type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).ToList();
         //遍历结果集
         foreach (T entity in result)
         {
             foreach (PropertyInfo propertyInfo in propertyList)
             {
                 string propertyName = propertyInfo.Name;
                 if  (dic.ContainsKey(propertyName))
                 {
                     //设置值
                     propertyInfo.SetValue(entity, dic[propertyName],  null );
                 }
             }
         }
         dbContext.SaveChanges();
     }

 调用:

1
2
3
4
5
Dictionary<string,object> dic= new  Dictionary<string,object>();
          dic.Add( "PersonID" , 2 );
          dic.Add( "UserName" , "keso" );
          helper.update(item => item.UserName.Contains( "keso" ), dic);
          Console.WriteLine( "修改成功" );

删除

方法:

1
2
3
4
5
6
7
8
9
10
11
12
/// <summary>
     /// 实体删除
     /// </summary>
     /// <param name="model"></param>
     public  void  delete(params T[] paramList)
     {
         foreach (var model in paramList)
         {
             dbContext.Entry<T>(model).State = EntityState.Deleted;
         }
         dbContext.SaveChanges();
     }

  调用:

1
2
var query = helper.getSearchList(item => item.UserName.Contains( "keso" ));
        helper.delete(query.ToArray());

 完整的EFHelper:

 个人Demo难免有表达不当或者技术失误的地方,如有不当,请多多指出,感激不尽~

本文转自Fly_Elephant博客园博客,原文链接:http://www.cnblogs.com/xiaofeixiang/p/4188600.html,如需转载请自行联系原作者

相关文章
|
6月前
|
安全 Java 数据安全/隐私保护
Java基础之类封装、继承、多态
Java基础的封装、继承和多态是OOP的核心。封装通过访问控制(如private)隐藏类的内部细节,提供公共接口供外部交互。例如,`Person`类封装`name`和`age`,通过`getName()`和`setAge()`方法访问。继承允许子类(如`Dog`)继承父类(如`Animal`)的属性和方法,并可扩展或覆盖。多态使得父类引用可指向子类对象,调用方法时根据实际对象类型执行,如不同动物的`makeSound()`。接口实现多态提供了一种定义行为而不必关心实现的方式。向上转型(子类→父类)安全且默认,而向下转型(父类→子类)需类型检查以避免异常。
38 1
|
7月前
|
Java 关系型数据库
Java类的设计与封装深入解析
Java类的设计与封装深入解析
82 0
|
7月前
|
Java
java类、封装、继承
java类、封装、继承
|
7月前
|
Java 关系型数据库
JAVA类的设计与封装
JAVA类的设计与封装
44 1
|
7月前
|
Java
【JAVA】为什么要使用封装以及如何封装
【JAVA】为什么要使用封装以及如何封装
154 0
【javaSE】 接口和Object类(一)
【javaSE】 接口和Object类(一)
|
存储 Java 编译器
【javaSE】 接口和Object类(二)
【javaSE】 接口和Object类(二)
|
Java
Java枚举类(1)--枚举类的定义、方法使用和接口实现
Java枚举类(1)--枚举类的定义、方法使用和接口实现
431 0
Java枚举类(1)--枚举类的定义、方法使用和接口实现
|
存储 Java
Java类&对象&封装
Java类&对象&封装
53 0
|
数据库
Entity Framework 一对一关系映射
Entity Framework 一对一关系映射
274 0
Entity Framework 一对一关系映射