爱起程,魔法之城音译歌词,狗仔谈拍陈思诚出轨门过程
书接上文，继续搭建我们基于.netcore 的开发框架。首先是我们的项目分层结构。
这个分层结构，是参考张老师的分层结构，但是实际项目中，我没有去实现仓储模型。因为我使用的是efcore ,最近也一直在想，efcore 在我们的架构体系中到底扮演着什么样的角色？？
当然，实现仓储层，也有他的好处，如果真的以后要更换orm框架的时候，不用去更改服务层逻辑，不用直接在仓储里面做更改就可以了。但是对于小项目，可能运行个十年都不会换数据库，不会换orm的项目，仓储层的意义在哪？
希望对此有自己想法的朋友一起讨论。在本系列里，我将保留仓储层。
上面的分层结构，很容易就搭建好了，但是基于.netcore 的项目，可能最主要的一点就是如何利用好di，怎么来实现依赖注入。
依照上图中的依赖关系，我们以此构建自己相应层级中的内容。
分别在irepository和repository项目下，新建base文件夹，并分别建立ibaserepository和baserepository
具体代码如下：
ibaserepository.cs：
我要评论 1 using sincere.core.model;
2 using system;
3 using system.collections.generic;
4 using system.data;
5 using system.data.sqlclient;
6 using system.linq.expressions;
7 using system.text;
8 using system.threading.tasks;
9
10 namespace sincere.core.irepository.base
11 {
12 public interface ibaserepository<tentity> where tentity : class
13 {
14 task<int> execute(string sql, list<sqlparameter> parms, commandtype cmdtype = commandtype.text);
15 task<list<tentity>> query(string sql, list<sqlparameter> parms, commandtype cmdtype = commandtype.text);
16 task<bool> insert(tentity model);
17 task<bool> insertrange(list<tentity> datas);
18
19 task<int> del(tentity model);
20
21 task<int> delby(expression<func<tentity, bool>> delwhere);
22
23 task<int> modify(tentity model);
24
25 task<int> modify(tentity model, params string[] propertynames);
26
27 task<int> modifyby(tentity model, expression<func<tentity, bool>> wherelambda, params string[] modifiedpropertynames);
28
29 task<list<tentity>> getlist();
30
31 task<list<tentity>> getlistby(expression<func<tentity, bool>> wherelambda);
32
33 task<tentity> getmodelbyid(expression<func<tentity, bool>> wherelambda);
34
35 task<list<tentity>> getlistby<tkey>(expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderlambda, bool isasc = true);
36
37 task<list<tentity>> getlistby<tkey>(int top, expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderlambda, bool isasc = true);
38
39 task<list<tentity>> getlistby<tkey1, tkey2>(expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey1>> orderlambda1, expression<func<tentity, tkey2>> orderlambda2, bool isasc1 = true, bool isasc2 = true);
40
41 task<list<tentity>> getlistby<tkey1, tkey2>(int top, expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey1>> orderlambda1, expression<func<tentity, tkey2>> orderlambda2, bool isasc1 = true, bool isasc2 = true);
42
43 task<list<tentity>> getpagedlist<tkey>(int pageindex, int pagesize, expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderbylambda, bool isasc = true);
44
45 task<pagemodel<tentity>> getpagedlist<tkey>(expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderbylambda, bool isasc = true, int pageindex = 1, int pagesize = 20);
46
47 void rollbackchanges();
48
49 }
50 }
baserepository.cs：
1 using microsoft.entityframeworkcore;
2 using sincere.core.irepository.base;
3 using sincere.core.model;
4 using sincere.core.model.models;
5 using system;
6 using system.collections.generic;
7 using system.data;
8 using system.data.sqlclient;
9 using system.linq;
10 using system.linq.expressions;
11 using system.reflection;
12 using system.text;
13 using system.threading.tasks;
14
15 namespace sincere.core.repository.base
16 {
17 public class baserepository<tentity> : ibaserepository<tentity> where tentity : class, new()
18 {
19 private basecorecontext _db;
20 private readonly dbset<tentity> _dbset;
21
22 internal basecorecontext db
23 {
24 get { return _db; }
25 private set { _db = value; }
26 }
27 public baserepository(ibasecontext mydbcontext)
28 {
29 this._db = mydbcontext as basecorecontext;
30 this._dbset = _db.set<tentity>();
31 }
32
33 #region insert
34
35 /// <summary>
36 /// 新增 实体
37 /// </summary>
38 /// <param name="model"></param>
39 /// <returns></returns>
40 //public async task<bool> insert(tentity model, bool issavechanges = false)
41 public async task<bool> insert(tentity model)
42 {
43 _db.set<tentity>().add(model);
44 //if (issavechanges)
45 //{
46 return await _db.savechangesasync() > 0;
47 //}
48 //else
49 //{
50 // return false;
51 //}
52
53 }
54
55 /// <summary>
56 /// 普通批量插入
57 /// </summary>
58 /// <param name="datas"></param>
59 public async task<bool> insertrange(list<tentity> datas)
60 {
61 await _db.set<tentity>().addrangeasync(datas);
62 return await _db.savechangesasync() == datas.count;
63 }
64
65 #endregion insert
66
67 #region delete
68
69 #region 2.0 根据id删除 + int del(t model)
70 /// <summary>
71 /// 2.0 根据id删除
72 /// </summary>
73 /// <param name="model">必须包含要删除id的对象</param>
74 /// <returns></returns>
75 public async task<int> del(tentity model)
76 {
77 _db.set<tentity>().attach(model);
78 _db.set<tentity>().remove(model);
79 return await _db.savechangesasync();
80 }
81 #endregion
82
83 #region 2.1 根据条件删除 + int delby(expression<func<t, bool>> delwhere)
84 /// <summary>
85 /// 2.1 根据条件删除
86 /// </summary>
87 /// <param name="delwhere"></param>
88 /// <returns>返回受影响的行数</returns>
89 public async task<int> delby(expression<func<tentity, bool>> delwhere)
90 {
91 //2.1.1 查询要删除的数据
92 list<tentity> listdeleting = _db.set<tentity>().where(delwhere).tolist();
93 //2.1.2 将要删除的数据 用删除方法添加到 ef 容器中
94 listdeleting.foreach(u =>
95 {
96 _db.set<tentity>().attach(u); //先附加到ef 容器
97 _db.set<tentity>().remove(u); //标识为删除状态
98 });
99 //2.1.3 一次性生成sql语句 到数据库执行删除
100 return await _db.savechangesasync();
101 }
102 #endregion
103
104
105 #endregion
106
107 #region update
108
109 #region 3.0 修改实体 + int modify(t model)
110 /// <summary>
111 /// 修改实体
112 /// </summary>
113 /// <param name="model"></param>
114 /// <returns></returns>
115 public async task<int> modify(tentity model)
116 {
117 //entityentry entry = _db.entry<tentity>(model);
118 _db.set<tentity>().update(model);
119 return await _db.savechangesasync();
120 }
121 #endregion
122
123 #region 3.1 修改实体，可修改指定属性 + int modify(t model, params string[] propertynames)
124 /// <summary>
125 /// 3.1 修改实体，可修改指定属性
126 /// </summary>
127 /// <param name="model"></param>
128 /// <param name="propertyname"></param>
129 /// <returns></returns>
130 public async task<int> modify(tentity model, params string[] propertynames)
131 {
132 //3.1.1 将对象添加到ef中
133 entityentry entry = _db.entry<tentity>(model);
134 //3.1.2 先设置对象的包装状态为 unchanged
135 entry.state = entitystate.unchanged;
136 //3.1.3 循环被修改的属性名数组
137 foreach (string propertyname in propertynames)
138 {
139 //将每个被修改的属性的状态设置为已修改状态；这样在后面生成的修改语句时，就只为标识为已修改的属性更新
140 entry.property(propertyname).ismodified = true;
141 }
142 return await _db.savechangesasync();
143 }
144 #endregion
145
146 #region 3.2 批量修改 + int modifyby(t model, expression<func<t, bool>> wherelambda, params string[] modifiedpropertynames)
147 /// <summary>
148 /// 3.2 批量修改
149 /// </summary>
150 /// <param name="model"></param>
151 /// <param name="wherelambda"></param>
152 /// <param name="modifiedpropertynames"></param>
153 /// <returns></returns>
154 public async task<int> modifyby(tentity model, expression<func<tentity, bool>> wherelambda, params string[] modifiedpropertynames)
155 {
156 //3.2.1 查询要修改的数据
157 list<tentity> listmodifing = _db.set<tentity>().where(wherelambda).tolist();
158 //3.2.2 获取实体类类型对象
159 type t = typeof(tentity);
160 //3.2.3 获取实体类所有的公共属性
161 list<propertyinfo> propertyinfos = t.getproperties(bindingflags.instance | bindingflags.public).tolist();
162 //3.2.4 创建实体属性字典集合
163 dictionary<string, propertyinfo> dicpropertys = new dictionary<string, propertyinfo>();
164 //3.2.5 将实体属性中要修改的属性名 添加到字典集合中 键：属性名 值：属性对象
165 propertyinfos.foreach(p =>
166 {
167 if (modifiedpropertynames.contains(p.name))
168 {
169 dicpropertys.add(p.name, p);
170 }
171 });
172 //3.2.6 循环要修改的属性名
173 foreach (string propertyname in modifiedpropertynames)
174 {
175 //判断要修改的属性名是否在实体类的属性集合中存在
176 if (dicpropertys.containskey(propertyname))
177 {
178 //如果存在，则取出要修改的属性对象
179 propertyinfo proinfo = dicpropertys[propertyname];
180 //取出要修改的值
181 object newvalue = proinfo.getvalue(model, null);
182 //批量设置要修改对象的属性
183 foreach (tentity item in listmodifing)
184 {
185 //为要修改的对象的要修改的属性设置新的值
186 proinfo.setvalue(item, newvalue, null);
187 }
188 }
189 }
190 //一次性生成sql语句 到数据库执行
191 return await _db.savechangesasync();
192 }
193 #endregion
194
195
196 #endregion update
197
198 #region select
199
200 #region 5.0 根据条件查询 + list<tentity> getlistby(expression<func<t, bool>> wherelambda)
201 /// <summary>
202 /// 5.0 根据条件查询
203 /// </summary>
204 /// <param name="wherelambda"></param>
205 /// <returns></returns>
206 public async task<list<tentity>> getlistby(expression<func<tentity, bool>> wherelambda)
207 {
208 return await _db.set<tentity>().where(wherelambda).asnotracking().tolistasync();
209 }
210
211 public async task<tentity> getmodelbyid(expression<func<tentity, bool>> wherelambda)
212 {
213 return await _db.set<tentity>().where(wherelambda).asnotracking().firstordefaultasync();
214 }
215 public async task<list<tentity>> getlist()
216 {
217 return await _db.set<tentity>().asnotracking().tolistasync();
218 }
219 #endregion
220
221 #region 5.1 根据条件查询，并排序 + list<tentity> getlistby<tkey>(expression<func<t, bool>> wherelambda, expression<func<t, tkey>> orderlambda, bool isasc = true)
222 /// <summary>
223 /// 5.1 根据条件查询，并排序
224 /// </summary>
225 /// <typeparam name="tkey"></typeparam>
226 /// <param name="wherelambda"></param>
227 /// <param name="orderlambda"></param>
228 /// <param name="isasc"></param>
229 /// <returns></returns>
230 public async task<list<tentity>> getlistby<tkey>(expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderlambda, bool isasc = true)
231 {
232 if (isasc)
233 {
234 return await _db.set<tentity>().where(wherelambda).orderby(orderlambda).asnotracking().tolistasync();
235 }
236 else
237 {
238 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderlambda).asnotracking().tolistasync();
239 }
240 }
241 #endregion
242
243 #region 5.2 根据条件查询top多少个，并排序 + list<tentity> getlistby<tkey>(int top, expression<func<t, bool>> wherelambda, expression<func<t, tkey>> orderlambda, bool isasc = true)
244 /// <summary>
245 /// 5.2 根据条件查询top多少个，并排序
246 /// </summary>
247 /// <typeparam name="tkey"></typeparam>
248 /// <param name="top"></param>
249 /// <param name="wherelambda"></param>
250 /// <param name="orderlambda"></param>
251 /// <param name="isasc"></param>
252 /// <returns></returns>
253 public async task<list<tentity>> getlistby<tkey>(int top, expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderlambda, bool isasc = true)
254 {
255 if (isasc)
256 {
257 return await _db.set<tentity>().where(wherelambda).orderby(orderlambda).take(top).asnotracking().tolistasync();
258 }
259 else
260 {
261 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderlambda).take(top).asnotracking().tolistasync();
262 }
263 }
264 #endregion
265
266 #region 5.3 根据条件排序查询 双排序 + list<tentity> getlistby<tkey1, tkey2>(expression<func<t, bool>> wherelambda, expression<func<t, tkey1>> orderlambda1, expression<func<t, tkey2>> orderlambda2, bool isasc1 = true, bool isasc2 = true)
267 /// <summary>
268 /// 5.3 根据条件排序查询 双排序
269 /// </summary>
270 /// <typeparam name="tkey1"></typeparam>
271 /// <typeparam name="tkey2"></typeparam>
272 /// <param name="wherelambda"></param>
273 /// <param name="orderlambda1"></param>
274 /// <param name="orderlambda2"></param>
275 /// <param name="isasc1"></param>
276 /// <param name="isasc2"></param>
277 /// <returns></returns>
278 public async task<list<tentity>> getlistby<tkey1, tkey2>(expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey1>> orderlambda1, expression<func<tentity, tkey2>> orderlambda2, bool isasc1 = true, bool isasc2 = true)
279 {
280 if (isasc1)
281 {
282 if (isasc2)
283 {
284 return await _db.set<tentity>().where(wherelambda).orderby(orderlambda1).thenby(orderlambda2).asnotracking().tolistasync();
285 }
286 else
287 {
288 return await _db.set<tentity>().where(wherelambda).orderby(orderlambda1).thenbydescending(orderlambda2).asnotracking().tolistasync();
289 }
290 }
291 else
292 {
293 if (isasc2)
294 {
295 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderlambda1).thenby(orderlambda2).asnotracking().tolistasync();
296 }
297 else
298 {
299 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderlambda1).thenbydescending(orderlambda2).asnotracking().tolistasync();
300 }
301 }
302 }
303 #endregion
304
305 #region 5.3 根据条件排序查询top个数 双排序 + list<tentity> getlistby<tkey1, tkey2>(int top, expression<func<t, bool>> wherelambda, system.linq.expressions.expression<func<t, tkey1>> orderlambda1, expression<func<t, tkey2>> orderlambda2, bool isasc1 = true, bool isasc2 = true)
306 /// <summary>
307 /// 5.3 根据条件排序查询top个数 双排序
308 /// </summary>
309 /// <typeparam name="tkey1"></typeparam>
310 /// <typeparam name="tkey2"></typeparam>
311 /// <param name="top"></param>
312 /// <param name="wherelambda"></param>
313 /// <param name="orderlambda1"></param>
314 /// <param name="orderlambda2"></param>
315 /// <param name="isasc1"></param>
316 /// <param name="isasc2"></param>
317 /// <returns></returns>
318 public async task<list<tentity>> getlistby<tkey1, tkey2>(int top, expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey1>> orderlambda1, expression<func<tentity, tkey2>> orderlambda2, bool isasc1 = true, bool isasc2 = true)
319 {
320 if (isasc1)
321 {
322 if (isasc2)
323 {
324 return await _db.set<tentity>().where(wherelambda).orderby(orderlambda1).thenby(orderlambda2).take(top).asnotracking().tolistasync();
325 }
326 else
327 {
328 return await _db.set<tentity>().where(wherelambda).orderby(orderlambda1).thenbydescending(orderlambda2).take(top).asnotracking().tolistasync();
329 }
330 }
331 else
332 {
333 if (isasc2)
334 {
335 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderlambda1).thenby(orderlambda2).take(top).asnotracking().tolistasync();
336 }
337 else
338 {
339 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderlambda1).thenbydescending(orderlambda2).take(top).asnotracking().tolistasync();
340 }
341 }
342 }
343 #endregion
344
345 #endregion select
346
347 #region 分页
348
349 #region 6.0 分页查询 + list<t> getpagedlist<tkey>
350 /// <summary>
351 /// 分页查询 + list<tentity> getpagedlist
352 /// </summary>
353 /// <typeparam name="tkey"></typeparam>
354 /// <param name="pageindex">页码</param>
355 /// <param name="pagesize">页容量</param>
356 /// <param name="wherelambda">条件 lambda表达式</param>
357 /// <param name="orderby">排序 lambda表达式</param>
358 /// <returns></returns>
359 public async task<list<tentity>> getpagedlist<tkey>(int pageindex, int pagesize, expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderbylambda, bool isasc = true)
360 {
361 // 分页 一定注意： skip 之前一定要 orderby
362 if (isasc)
363 {
364 return await _db.set<tentity>().where(wherelambda).orderby(orderbylambda).skip((pageindex - 1) * pagesize).take(pagesize).asnotracking().tolistasync();
365 }
366 else
367 {
368 return await _db.set<tentity>().where(wherelambda).orderbydescending(orderbylambda).skip((pageindex - 1) * pagesize).take(pagesize).asnotracking().tolistasync();
369 }
370 }
371 #endregion
372
373 #region 6.1分页查询 带输出 +list<tentity> getpagedlist<tkey>
374 /// <summary>
375 /// 分页查询 带输出
376 /// </summary>
377 /// <typeparam name="tkey"></typeparam>
378 /// <param name="pageindex"></param>
379 /// <param name="pagesize"></param>
380 /// <param name="rowcount"></param>
381 /// <param name="wherelambda"></param>
382 /// <param name="orderby"></param>
383 /// <param name="isasc"></param>
384 /// <returns></returns>
385 public async task<pagemodel<tentity>> getpagedlist<tkey>(expression<func<tentity, bool>> wherelambda, expression<func<tentity, tkey>> orderbylambda, bool isasc = true, int pageindex = 1, int pagesize = 20)
386 {
387 var rowcount = await _db.set<tentity>().where(wherelambda).countasync();
388
389 int pagecount = (math.ceiling(rowcount.objtodecimal() / pagesize.objtodecimal())).objtoint();
390
391 list<tentity> list = null;
392
393 if (isasc)
394 {
395 list = await _db.set<tentity>().orderby(orderbylambda).where(wherelambda).skip((pageindex - 1) * pagesize).take(pagesize).asnotracking().tolistasync();
396 }
397 else
398 {
399 list = await _db.set<tentity>().orderbydescending(orderbylambda).where(wherelambda).skip((pageindex - 1) * pagesize).take(pagesize).asnotracking().tolistasync();
400 }
401
402 return new pagemodel<tentity>() { datacount = rowcount, pagecount = pagecount, page = pageindex, pagesize = pagesize, data = list };
403 }
404 #endregion
405
406 #endregion
407
408 #region orther
409
410 /// <summary>
411 /// 执行存储过程或自定义sql语句--返回集合
412 /// </summary>
413 /// <param name="sql"></param>
414 /// <param name="parms"></param>
415 /// <param name="cmdtype"></param>
416 /// <returns></returns>
417 public async task<list<tentity>> query(string sql, list<sqlparameter> parms, commandtype cmdtype = commandtype.text)
418 {
419 //存储过程（exec getactionurlid @name,@id）
420 if (cmdtype == commandtype.storedprocedure)
421 {
422 stringbuilder paranames = new stringbuilder();
423 foreach (var sqlpara in parms)
424 {
425 paranames.append($" @{sqlpara},");
426 }
427 sql = paranames.length > 0 ? $"exec {sql} {paranames.tostring().trim(',')}" : $"exec {sql} ";
428 }
429
430 return await _db.set<tentity>().fromsql(sql).tolistasync();
431
432 }
433
434
435 /// <summary>
436 /// 回滚
437 /// </summary>
438 public void rollbackchanges()
439 {
440 var items = _db.changetracker.entries().tolist();
441 items.foreach(o => o.state = entitystate.unchanged);
442 }
443
444 /// <summary>
445 /// 自定义语句和存储过程的增删改--返回影响的行数
446 /// </summary>
447 /// <param name="sql"></param>
448 /// <param name="parms"></param>
449 /// <param name="cmdtype"></param>
450 /// <returns></returns>
451 public async task<int> execute(string sql, list<sqlparameter> parms, commandtype cmdtype = commandtype.text)
452 {
453 //存储过程（exec getactionurlid @name,@id）
454 if (cmdtype == commandtype.storedprocedure)
455 {
456 stringbuilder paranames = new stringbuilder();
457 foreach (var sqlpara in parms)
458 {
459 paranames.append($" @{sqlpara},");
460 }
461 sql = paranames.length > 0 ?
462 $"exec {sql} {paranames.tostring().trim(',')}" :
463 $"exec {sql} ";
464 }
465
466 int ret = await _db.database.executesqlcommandasync(sql, parms.toarray());
467 return 0;
468 }
469
470
471 #endregion orther
472 }
473 }
baserepository中主要是实现了一些基础的curd操作，并且封装了一些常用的数据库操作。比如分页、执行sql语句等等
如果直接复制以上代码，会报错，因为你的项目中还没有数据上下文：
下面就引入我们将要使用的orm框架--efcore
首先，在model层总引入：
install-package microsoft.entityframeworkcore -version 2.2.4
install-package microsoft.entityframeworkcore.sqlserver -version 2.2.4
install-package microsoft.entityframeworkcore.tools -version 2.2.4
此系类中我们采用databasefrist的方式来生成model文件和上下文。在数据库中先建用于测试的表--advertisement
语句如下：
1 use [basecore] 2 go 3 4 /****** object: table [dbo].[advertisement] script date: 08/28/2019 10:43:34 ******/ 5 set ansi_nulls on 6 go 7 8 set quoted_identifier on 9 go 10 11 create table [dbo].[advertisement]( 12 [id] [int] identity(1,1) not null, 13 [createdate] [datetime] not null, 14 [imgurl] [nvarchar](512) null, 15 [title] [nvarchar](64) null, 16 [url] [nvarchar](256) null, 17 [remark] [nvarchar](max) null, 18 constraint [pk_dbo.advertisement] primary key clustered 19 ( 20 [id] asc 21 )with (pad_index = off, statistics_norecompute = off, ignore_dup_key = off, allow_row_locks = on, allow_page_locks = on) on [primary] 22 ) on [primary] 23 24 go
然后使用工具scaffold-dbcontext（数据库上下文脚手架）来生成model类文件和dbcontext。
命令如下：
scaffold-dbcontext "server=.;database=xxx;uid=sa;pwd=密码;" microsoft.entityframeworkcore.sqlserver -o models -f -context basecorecontext
在执行这个命令之前，需要将model层设置为启动项目。否则会报错。
另外当你的项目buid没有通过的话，会出现如下错误。
我一般的解决方案就是将其他项目全部先卸载，只留下一个model，然后再执行以上语句。
这时，在你的model项目下的models文件夹下，就会出现如下文件：
打开basecorecontext.cs 文件，删除onconfiguring 方法，至于为什么，我会在后面说明。
为了让数据库上下文也能用di的方式进行使用，我新建了一个, ibasecontext接口，并且让basecorecontext 实现这个接口。
这个时候，仓储的基础父类应该是不会报错。但是我在basecorecontext里实现了一个分页操作，用到了一个pagemodel 。需要添加到你的model层里面
代码如下：
1 using system;
2 using system.collections.generic;
3 using system.text;
4
5 namespace sincere.core.model
6 {
7 /// <summary>
8 /// 通用分页信息类
9 /// </summary>
10 public class pagemodel<t>
11 {
12 /// <summary>
13 /// 当前页标
14 /// </summary>
15 public int page { get; set; } = 1;
16 /// <summary>
17 /// 总页数
18 /// </summary>
19 public int pagecount { get; set; } = 6;
20 /// <summary>
21 /// 数据总数
22 /// </summary>
23 public int datacount { get; set; } = 0;
24 /// <summary>
25 /// 每页大小
26 /// </summary>
27 public int pagesize { set; get; }
28 /// <summary>
29 /// 返回数据
30 /// </summary>
31 public list<t> data { get; set; }
32
33 }
34 }
另外里面还有一些 转换函数，请参考源码：https://github.com/xzhencheng/sincere.core.git
至此，项目的仓储层的基础代码就构建完了，今天的作业就先写到这！
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
asp.net搭建博客，使用BlogEngine.NET+MySql搭建博客
网友评论