一步一步搭建开发框架(三)基类基接口

1,AdoNetDal和EfDal都实现IDal这个接口,公共的方法写到接口中,接口中的代码!

 1 namespace PCITC.OA.IDal
 2 {
 3     public interface IUserInforDal
 4     {
 5         UserInfor Add(UserInfor userInfor);
 6
 7         bool Update(UserInfor userInfor);
 8
 9         bool Delete(UserInfor userInfor);
10
11         int Delete(params int[] ids);
12
13         /// <summary>
14         /// 基本过滤
15         /// </summary>
16         /// <param name="whereLambda">过滤的Lambda表达式</param>
17         /// <returns></returns>
18         IQueryable<UserInfor> LoadDatas(Func<UserInfor, bool> whereLambda);
19
20         /// <summary>
21         /// 分页
22         /// </summary>
23         /// <typeparam name="S">排序字段的类型</typeparam>
24         /// <param name="pagesize">每页多少条</param>
25         /// <param name="pageindex">当前第几页</param>
26         /// <param name="total">总条数</param>
27         /// <param name="whereLambda">过滤的Lambda表达式</param>
28         /// <param name="orderByLambda">排序的Lambda表达式</param>
29         /// <returns></returns>
30         IQueryable<UserInfor> LoadDatas<S>(int pagesize,int pageindex,out int total,Func<UserInfor,bool> whereLambda,Func<UserInfor,S> orderByLambda,bool isAsc);
31     }
32 }

2,EfDal层的代码

 1 namespace PCITC.OA.Dal
 2 {
 3     public class UserInforDal:IUserInforDal
 4     {
 5         DataModelContainer dbc = new DataModelContainer();
 6
 7         public UserInfor Add(UserInfor userInfor)
 8         {
 9             dbc.UserInfor.Add(userInfor);
10             dbc.SaveChanges();
11             return userInfor;
12         }
13
14         public bool Update(UserInfor userInfor)
15         {
16             dbc.UserInfor.Attach(userInfor);
17             dbc.Entry(userInfor).State = EntityState.Modified;
18             return dbc.SaveChanges() > 0;
19         }
20
21         public bool Delete(UserInfor userInfor)
22         {
23             dbc.UserInfor.Attach(userInfor);
24             dbc.Entry(userInfor).State = EntityState.Deleted;
25             return dbc.SaveChanges() > 0;
26         }
27
28         public int Delete(params int[] ids)
29         {
30             foreach (int id in ids)
31             {
32                 UserInfor user = new UserInfor();
33                 user.Id = id;
34                 dbc.UserInfor.Attach(user);
35                 dbc.Entry(user).State = EntityState.Deleted;
36             }
37             return dbc.SaveChanges();
38         }
39
40         public IQueryable<UserInfor> LoadDatas(Func<UserInfor, bool> whereLambda)
41         {
42             return dbc.UserInfor.Where(whereLambda).AsQueryable();
43         }
44
45         public IQueryable<UserInfor> LoadDatas<S>(int pagesize, int pageindex, out int total, Func<UserInfor, bool> whereLambda,Func<UserInfor,S> orderByLambda,bool isAsc)
46         {
47             total = dbc.UserInfor.Where(whereLambda).Count();
48             if (isAsc)
49             {
50                 return dbc.UserInfor.Where(whereLambda).OrderBy(orderByLambda).Skip(pagesize * (pageindex - 1)).Take(pagesize).AsQueryable();
51             }
52             else
53             {
54                 return dbc.UserInfor.Where(whereLambda).OrderByDescending(orderByLambda).Skip(pagesize * (pageindex - 1)).Take(pagesize).AsQueryable();
55             }
56
57         }
58
59
60
61     }
62 }

3,这个时候当数据库中有第二张表Role表的时候,就需要同样有IRoleDal,然后在这个接口中跟IUserInfor一样写增删改查的方法。这个时候我们利用基接口和泛型来将接口中重复的代码提取到基接口中。

 1 namespace PCITC.OA.IDal
 2 {
 3     public interface IBaseDal<T> where T:class,new()
 4     {
 5         T Add(T entity);
 6
 7         bool Update(T entity);
 8
 9         bool Delete(T entity);
10
11         int Delete(params int[] ids);
12
13         /// <summary>
14         /// 基本过滤
15         /// </summary>
16         /// <param name="whereLambda">过滤的Lambda表达式</param>
17         /// <returns></returns>
18         IQueryable<T> LoadDatas(Func<T, bool> whereLambda);
19
20         /// <summary>
21         /// 分页
22         /// </summary>
23         /// <typeparam name="S">排序字段的类型</typeparam>
24         /// <param name="pagesize">每页多少条</param>
25         /// <param name="pageindex">当前第几页</param>
26         /// <param name="total">总条数</param>
27         /// <param name="whereLambda">过滤的Lambda表达式</param>
28         /// <param name="orderByLambda">排序的Lambda表达式</param>
29         /// <returns></returns>
30         IQueryable<T> LoadDatas<S>(int pagesize, int pageindex, out int total, Func<T, bool> whereLambda, Func<T, S> orderByLambda, bool isAsc);
31     }
32 }

4,同样的RoleDal中具体的实现方法和UserInfor中具体的实现方法也是重复的,这个时候将重复的实现代码放到基类中。

 1 namespace PCITC.OA.Dal
 2 {
 3     public class BaseDal<T> where T:class,new ()
 4     {
 5         DataModelContainer dbc = new DataModelContainer();
 6         public T Add(T entity)
 7         {
 8             dbc.Set<T>().Add(entity);
 9             dbc.SaveChanges();
10             return entity;
11         }
12
13         public bool Update(T entity)
14         {
15             dbc.Set<T>().Attach(entity);
16             dbc.Entry(entity).State = EntityState.Modified;
17             return dbc.SaveChanges() > 0;
18         }
19
20         public bool Delete(T entity)
21         {
22             dbc.Set<T>().Attach(entity);
23             dbc.Entry(entity).State = EntityState.Deleted;
24             return dbc.SaveChanges() > 0;
25         }
26
27         public int Delete(params int[] ids)
28         {
29             foreach (int id in ids)
30             {
31                 //首先可以泛型的基类约束给Id字段赋值,也可以通过反射!
32                 T entity = dbc.Set<T>().Find(id);//Find方法会首先从内存中查找,内存中没有,采取查寻
33                 dbc.Set<T>().Remove(entity);
34             }
35             return dbc.SaveChanges();
36         }
37
38         public IQueryable<T> LoadDatas(Func<T, bool> whereLambda)
39         {
40             return dbc.Set<T>().Where(whereLambda).AsQueryable();
41         }
42
43         public IQueryable<T> LoadDatas<S>(int pagesize, int pageindex, out int total, Func<T, bool> whereLambda, Func<T, S> orderByLambda, bool isAsc)
44         {
45             total = dbc.Set<T>().Where(whereLambda).Count();
46             if (isAsc)
47             {
48                 return dbc.Set<T>().Where(whereLambda).OrderBy(orderByLambda).Skip(pagesize * (pageindex - 1)).Take(pagesize).AsQueryable();
49             }
50             else
51             {
52                 return dbc.Set<T>().Where(whereLambda).OrderByDescending(orderByLambda).Skip(pagesize * (pageindex - 1)).Take(pagesize).AsQueryable();
53             }
54
55         }
56     }
57 }

5,架构图

一步一步搭建开发框架(三)基类基接口,布布扣,bubuko.com

时间: 2024-10-13 07:00:01

一步一步搭建开发框架(三)基类基接口的相关文章

C#编程语言与面向对象——抽象基类与接口

在一个类前加“abstract”关键字,此类就成为抽象类. 对应的,在一个方法前加“abstract”关键字,此方法就成为抽象方法. abstract class Fruit //抽象类 { public abstract void GrowInArea();//抽象方法 } 注意抽象方法不能又实现代码,在方法名后直接跟一个分号. 抽象类专用于派生出子类,子类必须实现抽象类中所生命的方法.否子子类仍是抽象类. 抽象类一般用于表达一种比较抽象的事物,比如说“水果”,而抽象方法则说明此抽象类应该具有

基类VS接口

该篇引用 CLR via C# 中的13.11节. 应该设计基类还是接口,这个问题不能一概而论,下面提供一些指导性原则: 1. IS_A关系(指属于,例如汽车属于交通工具) vs CAN_DO关系(指能做某事,例如一个类型能将自己的实例转换另一个类型)  类型只能继承一个实现.如果派生类型不具有与基类的IS_A关系,就不应使用基类,而应该使用接口.接口意味着CAN_DO关系.如果多种对象类型都具有CAN_DO功能,就使用接口.例如,一个类型能将自己的实例转换成另一个类型,一个类型能序列化自己的实

五、抽象基类与接口

5.1 抽象类与抽象方法 在一个类前面加上“abstract”关键字,此类就成为了抽象类. 对应的,一个方法类前面加上“abstract”关键字,此方法就成为了抽象方法. abstract class Fruit   //抽象类 { public abstract void GrowInArea();  //抽象方法 } 注意抽象方法不能有实现代码,在函数名后直接跟一个分号. 抽象类专用于派生出子类,子类必须实现抽象类所声明的抽象方法,否则,子类仍是抽象类. 抽象类一般用于表达一种比较抽象的事物

抽象基类与接口

5.1抽象类与抽象方法 在一个类前面加上“abstract”关键字,此类就成为了抽象类. 对应地,一个方法类前面加上“abstract”关键字,此方法就成为了抽象方法. 注意抽象方法不能有实现代码,在函数名后直接跟一个分号. 抽象类专用于派生出子类,子类必须实现抽象类所声明的抽象方法,否则,子类仍是抽 象类. 抽象类一般用于表达一种比较抽象的事物,比如前面所说的“水果”,而抽象方法则说 明此抽象类应该具有的某种性质,比如 Fruit类中有一个抽象方法  GrowInArea(),说明水果 一定有

类,抽象基类,接口类三者间的区别与联系(C++)

联系很明显,三个都是‘类’,如果读者对类的概念不清楚,可以参照wid的博文http://www.cnblogs.com/mr-wid/archive/2013/02/18/2916309.html. 下面着重解释一下区别,但此文仅是个人理解,如果觉得我说的不对的地方,还请赐教. (1)结构上的区别: 普通类:数据+方法+实现 抽象类:数据+方法(一定包含虚方法n>=1)+部分方法的实现 接口类:方法(纯虚方法) (2)概念上的区别: 普通的类和另外两个的区别很明显,普通类就是猫狗之类的,而抽象类

6、面向对象以及winform的简单运用(抽象基类与接口)

抽象类与抽象方法 1.书写规范: 在类前面加上abstract关键字,就成为了抽象类:在一个方法前面加上abstract关键字,就成为了抽象方法(抽象方法不能有实现方法,直接在后面加分号) 例: abstract class Chouxiang //抽象类 { public abstract void fangfa(); //抽象方法 } 2.抽象类的注意事项: 1)当一个类变为抽象类之后就不能作为对象来使用了,无法new出来 2)抽象方法必须放在抽象类里面(但抽象类中不一定有抽象方法) 3)没

12-14面向对象--抽象基类、接口、委托

一.抽象类与抽象方法 1.在一个类前面加上abstract关键字,此类就成为了抽象类. 1)当一个类变成抽象类时,就不能作为一个对象使用了,也就是说不能创建新对象,不能new初始化. 2)抽象方法只是一个方法,不能写方法. 3)当一个类继承的是抽象类时,必须要把抽象类的抽象方法重写(override)才可以实现方法. 4)抽象方法必须放在抽象类里面才能使用,抽象方法是在抽象子类中实现的,也就是说抽象子类实现抽象父类所有的抽象方法. 5)有抽象方法的一定是抽象类:有抽象类但不一定有抽象方法. 6)

[Effective Java 读书笔记] 第三章类和接口 第二十-二十一条

第二十条 用函数对象表示策略 函数指针(JAVA的函数指针,是指使用对象的引用来作为参数,传递给另一个对象的方法)主要用来实现策略模式,为了在JAVA中实现这种模式,要申明一个接口来表示该策略,并为每个具体策略申明一个实现了该接口的类. 如果这个策略只被执行一次,使用匿名类,如果重复使用,则通常实现为私有的静态成员类,并通过共有的静态final域导出(最后一个例子),其类型为该策略接口. 第二十一条 优先考虑静态成员类 嵌套类主要有四种:静态成员类,非静态成员类,匿名类,局部类 静态成员类,一般

[Effective Java 读书笔记] 第三章类和接口 第十六条

第十六条 复合优先于继承 如果不确定B和A的关系是,is-a的关系,B确实也是A,那么久不应该使用B继承A,否则会暴露实现细节, 你的实现都会限制在原始的实现上. 书中举的第一个例子,实现了一个类extends HashSet类,因为缺少对HashSet类的addAll方法的理解(addAll会重复调用add方法),导致多统计了一倍的调用次数,这就是自己的实现限制在父类的实现上. 同时书中还有一个说明,如果超类在后续的版本中增加了一个新的方法, 正好和你的类里新增的方法签名一致(参数列表和函数名