三层架构泛型应用

1.三层架构一般包含：UI层、DAL层、BLL层，其中每层由Model实体类来传递，所以Model也算是三层架构之一了，例外为了数据库的迁移或者更OO点，DAL层就衍生出了IDAL接口。Model就是简单的对应数据库里面的类，DAL层就是主要操作数据库的方法了，BLL这个就看业务了。而DAL层大部分的方法都是差不多，无非就是几个Insert，Update,Delete,Select

2.泛型：泛型一个类型的模板，只要你定义了一个泛型类，就相当于定义了N个类，每个类的类型不一样而已

不使用泛型的设计：

 

1. public interface IUserDAL    //数据访问层接口
2.      {  
3.         int Insert(User model);  
4.         int Update(User model);  
5.         int Delete(int id);  
6.         User GetModel(int id);  
7.         DataTable GetList();  
8.     } 

 

1. public class UserBLL    //业务逻辑层
2.      {  
3.          private IUserDAL dal = new UserDAL();  
4.    
5.          public int Insert(User model)  
6.          {  
7.              return dal.Insert(model);  
8.          }  
9.    
10.          public int Update(User model)  
11.          {  
12.              return dal.Update(model);  
13.          }  
14.          public int Delete(int id)  
15.          {  
16.              return dal.Delete(id);  
17.          }  
18.          public T GetModel(int id)  
19.          {  
20.              return dal.GetModel(id);  
21.          }  
22.          public DataTable GetList()  
23.          {  
24.              return dal.GetList();  
25.          }  
26.      } 

使用泛型改写上面的设计：

//数据访问层泛型改写：定义一个数据访问层接口，可以用于不同对象去继承，比如：User,Order,Product...

1. public interface IDAL<T> where T : class  
2.     {  
3.         int Insert(T model);  
4.         int Update(T model);  
5.         int Delete(int id);  
6.         T GetModel(int id);  
7.         IList<T> GetList();  
8.    } 

1. public class UserDAL : IDAL<User> 
2.     {  
3.         #region IDAL<User> 成员  
4.         public int Insert(User model)  
5.         {  
6.             //coding  
7.         }  
8.         public int Update(User model)  
9.         {  
10.             //coding  
11.         }  
12.         public int Delete(object id)  
13.         {  
14.             //coding  
15.         }  
16.         public User GetModel(object id)  
17.         {  
18.             //coding  
19.         }  
20.         public IList<User> GetList()  
21.         {  
22.             //coding  
23.         }  
24.         #endregion  
25.     } 

//业务逻辑层泛型改写：

1. public class BaseBLL<T, D> 
2.         where T : class  
3.         where D : IDAL<T>,new ()  
4.     {  
5.         private D dal = new D();  
6.         public virtual int Insert(T model)  
7.         {  
8.             return dal.Insert(model);  
9.         }  
10.         public virtual int Update(T model)  
11.         {  
12.             return dal.Update(model);  
13.         }  
14.         public virtual int Delete(object id)  
15.         {  
16.             return dal.Delete(id);  
17.         }  
18.         public virtual T GetModel(object id)  
19.         {  
20.             return dal.GetModel(id);  
21.         }  
22.         public virtual IList<T> GetList()  
23.         {  
24.             return dal.GetList(model);  
25.         }  
26.     } 

1. public class UserBLL : BaseBLL<User, UserDAL> 
2.     {  
3.          
4.     } 

 

如果UserBLL没有任何业务的话，那就不要继承了，在UI直接用BaseBLL这个泛型类就可以，调用也很简单

BaseBLL<User> dal=new BaseBLL<User>()