EF Learning Notes-general additions and deletions scheme

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

I've just been in contact with EF for a long time, and I don't know what the strength is, but it looks like EF provides a general addition and deletion change function. In the past, some ORM methods have been used, although there are code generators, but the amount of code is generally more. This time using EF, I think, can I try to write some common methods, add tables later, entity class, just do a few changes, you can have basic additions and deletions to check the function?

The scheme is as follows:

1, divided into several parts: BLL, DAL, Model, Interface. Where the code generated by EF is placed in model. Because it does not want to operate the model directly from the BLL, it also adds a DAL, which is further encapsulated in the EF method for the BLL invocation. As for the interface, it is due to the following considerations: additions and deletions, both the BLL and the DAL need to be implemented, so they better implement the same interface; Most importantly, because the interface is used, it is convenient to invoke the Dal object in the BLL.

These sections are described as follows:

1, Interface interface

[CSharp]View Plain copy

1. Public Interface IEntity
2. {
3. long _id { get;}
4. }

[CSharp]View Plain copy

2. Public interface icommon<t> where T: class,ientity
4. {
6. T ADD (t model);
8. T Update (t model);
10. void Delete (T model);
12. //Press primary key to delete, KeyValues is primary key value
14. void Delete (params object[] keyvalues);
16. //keyvalues is the primary key value
18. T Find (params object[] keyvalues);
20. List<t> FindAll ();
22. }

2. DAL

General additions and deletions to change the code:

[CSharp]View Plain copy

2. Public Abstract class basecommon<t>: interface.icommon<t> where T: class,interface.ientity
4. {
6. DbContext DB;
8. Public Basecommon (DbContext context)
10. {
12. this.db = context;
14. }
18. Public DbContext Context
20. {
22. Get
24. {
26. return DB;
28. }
30. }
34. #region icommon<t>
36. Public T ADD (t model)
38. {
40. Db. Set<t> (). ADD (model);
42. Db. SaveChanges ();
44. return model;
46. }
48. Public T Update (t model)
50. {
52. if (db. Entry<t> (model). state = = entitystate.modified)
54. {
56. Db. SaveChanges ();
58. }
60. Else if (db. Entry<t> (model). state = = entitystate.detached)
62. {
64. Try
66. {
68. Db. Set<t> (). Attach (model);
70. Db. Entry<t> (model). state = entitystate.modified;
72. }
74. catch (InvalidOperationException)
76. {
78. T old = Find (model._id);
80. Db. Entry (old). Currentvalues.setvalues (model);
82. }
84. Db. SaveChanges ();
86. }
88. return model;
90. }
92. public void Delete (T model)
94. {
96. Db. Set<t> (). Remove (model);
98. Db. SaveChanges ();
100. }
102. public void Delete (params object[] keyvalues)
104. {
106. T model = Find (keyvalues);
108. if (model = null)
110. {
112. Db. Set<t> (). Remove (model);
114. Db. SaveChanges ();
116. }
118. }
120. Public T Find (params object[] keyvalues)
122. {
124. return DB. Set<t> ().  Find (KeyValues);
126. }
128. Public list<t> FindAll ()
130. {
132. return DB. Set<t> ().  ToList ();
134. }
136. #endregion
138. }

In this, has been encapsulated the general method of adding and deleting. and the corresponding database of each table object of those classes, just inherit this Basecommon class, you can have additions and deletions to change the function. Such as:

[CSharp]View Plain copy

1. Public partial class Tablea:basecommon<model.tablea> {}

In this way, the TableA object will naturally have the ability to change and delete. If we need to expand its functionality, we can write another TableA partial class.

Later, add a table TableB, in the Dal here, generally only a new sentence:

[CSharp]View Plain copy

1. Public partial class Tableb:basecommon<model.tableb> {}

Isn't it convenient?

3. BLL

The BLL is for the UI layer, or the previous layer is called, so it should also have the basic function of the pruning check for each object. Of course, the BLL does not need to be directly implemented by invoking the DAL:

[CSharp]View Plain copy

2. Public Abstract class Common<tdal, tmodel>: interface.icommon<tmodel>
4. Where Tdal: class,new ()
6. Where TModel: class, Interface.ientity
8. {
10. protected Tdal dal;
12. private interface.icommon<tmodel> Common;
16. Public Common ()
18. {
20. Dal = new Tdal ();
22. Common = (interface.icommon<tmodel>) dal;
24. }
28. #region icommon<tmodel>
30. Public TModel ADD (TModel model)
32. {
34. return common.  ADD (model);
36. }
38. Public TModel Update (TModel model)
40. {
42. return common.  Update (model);
44. }
46. public void Delete (TModel model)
48. {
50. Common. Delete (model);
52. }
54. public void Delete (params object[] keyvalues)
56. {
58. Common. Delete (KeyValues);
60. }
62. Public TModel Find (params object[] keyvalues)
64. {
66. return common.  Find (KeyValues);
68. }
70. Public list<tmodel> FindAll ()
72. {
74. return common.  FindAll ();
76. }
78. #endregion
80. }

Similar to the DAL, the TableA object is here:

[CSharp]View Plain copy

1. Public partial class Tablea:common<dal. TableA, model.tablea> {}

Similarly, if later added the table Talbeb, here also only adds a sentence.

Another advantage here is that for external calls, there is no need to know generics, which is a TableA table = new Talbea ();

EF Learning Notes-general additions and deletions scheme