EF学习笔记——通用增删改查方案

http://blog.csdn.net/leftfist/article/details/25005307

我刚接触EF未久，还不知道它有什么强大之处，但看上去，EF提供了一般的增删改查功能。以往用过一些ORM方法，尽管有代码生成器，但代码量总的 来说比较多。这次采用EF，我就想，能不能尽量写出一些通用的方法，以后添加表、实体类，只需做很少的改动，就能拥有基本的增删改查功能呢？

方案如下：

1、 分为几个部分：BLL、DAL、Model、Interface。其中，EF生成的代码放在Model。因为不想由BLL直接操作Model，因此还是增 加一个DAL，由它来对EF的方法作进一步的封装，供BLL调用。至于接口，则是出于如下考虑：增删改查，BLL和DAL都需要实现，因此它们最好实现同 一接口；最重要的，因为使用了接口，在BLL中，方便调用DAL对象。

这几个部分分别介绍如下：

1、接口Interface

1. public interface IEntity
2. {
3. long _ID { get;}
4. }

1. public interface ICommon<T> where T : class,IEntity
2. {
3. T Add(T model);
4. T Update(T model);
5. void Delete(T model);
6. //按主键删除,keyValues是主键值
7. void Delete(params object[] keyValues);
8. //keyValues是主键值
9. T Find(params object[] keyValues);
10. List<T> FindAll();
11. }

2、DAL

通用的增删改查代码：

1. public abstract class BaseCommon<T> : Interface.ICommon<T> where T : class,Interface.IEntity
2. {
3. DbContext db;
4. public BaseCommon(DbContext context)
5. {
6. this.db = context;
7. }
8. public DbContext Context
9. {
10. get
11. {
12. return db;
13. }
14. }
15. #region ICommon<T>
16. public T Add(T model)
17. {
18. db.Set<T>().Add(model);
19. db.SaveChanges();
20. return model;
21. }
22. public T Update(T model)
23. {
24. if (db.Entry<T>(model).State == EntityState.Modified)
25. {
26. db.SaveChanges();
27. }
28. else if (db.Entry<T>(model).State == EntityState.Detached)
29. {
30. try
31. {
32. db.Set<T>().Attach(model);
33. db.Entry<T>(model).State = EntityState.Modified;
34. }
35. catch (InvalidOperationException)
36. {
37. T old = Find(model._ID);
38. db.Entry(old).CurrentValues.SetValues(model);
39. }
40. db.SaveChanges();
41. }
42. return model;
43. }
44. public void Delete(T model)
45. {
46. db.Set<T>().Remove(model);
47. db.SaveChanges();
48. }
49. public void Delete(params object[] keyValues)
50. {
51. T model = Find(keyValues);
52. if (model != null)
53. {
54. db.Set<T>().Remove(model);
55. db.SaveChanges();
56. }
57. }
58. public T Find(params object[] keyValues)
59. {
60. return db.Set<T>().Find(keyValues);
61. }
62. public List<T> FindAll()
63. {
64. return db.Set<T>().ToList();
65. }
66. #endregion
67. }

这里面，已经封装好了一般的增删改查方法。而对应数据库每个表对象的那些类，只需继承这个BaseCommon类，即可拥有增删改查功能。如：

1. public partial class TableA : BaseCommon<Model.TableA> { }

这样，TableA对象会自然拥有增删改查功能。假如需要扩充它的功能，我们可以再写一个TableA的分部类。

以后，新增一个表TableB，在DAL这里，一般情况下只需新增一句：

1. public partial class TableB : BaseCommon<Model.TableB> { }

是不是很方便？

3、BLL

BLL是供UI层，或者上一层调用的，因此，它每个对象，也应该有增删改查的基本功能。当然，BLL无须直接实现，是通过调用DAL来实现：

1. public abstract class Common<TDAL, TModel> : Interface.ICommon<TModel>
2. where TDAL : class ,new()
3. where TModel : class ,Interface.IEntity
4. {
5. protected TDAL dal;
6. private Interface.ICommon<TModel> common;
7. public Common()
8. {
9. dal = new TDAL();
10. common = (Interface.ICommon<TModel>)dal;
11. }
12. #region ICommon<TModel>
13. public TModel Add(TModel model)
14. {
15. return common.Add(model);
16. }
17. public TModel Update(TModel model)
18. {
19. return common.Update(model);
20. }
21. public void Delete(TModel model)
22. {
23. common.Delete(model);
24. }
25. public void Delete(params object[] keyValues)
26. {
27. common.Delete(keyValues);
28. }
29. public TModel Find(params object[] keyValues)
30. {
31. return common.Find(keyValues);
32. }
33. public List<TModel> FindAll()
34. {
35. return common.FindAll();
36. }
37. #endregion
38. }

与DAL类似，TableA对象在这里是这样的：

1. public partial class TableA : Common<DAL.TableA, Model.TableA> { }

同理，如果以后新增了表TalbeB，在这里也只是新增一句而已。

这里还有一个好处，就是对外界调用而言，根本不需要知道泛型，就是一个 TableA table = new TalbeA();就可以了。