.net项目开发系统设计
作者:dave 日期:2020-07-28

不久之前我们工作室开发了基于.net项目系统的一套搭建sprint.NET+NHibernate+MVC+WCF+EasyUI等中小型企业级系统开发平台,现在,整个把开发过程一步一步地整理出来,与大家分享。

我们的底层开发平台是sprint.NET+NHibernate+MVC+WCF+EasyUI方式开发,顺便加点Spring.net注入的部分,当然我们最主要的关于权限设计、业务设计,而架构,咱们没有学过太复杂的架构,我们还是以最常用的MVC架构开始搭建。

我们将首先解释关于项目建设的一部分,我们的项目主要分为6个部分,业务逻辑层,数据访问层、页面层,和一个公共类的数据模型层,我们每层在相应的抽象接口的基础上,这样一层一层的同时,面向接口编程,Spring.NET管理之间的关系,达到解耦的目的。

时有Spring.NET来管理层之间的关系,达到解耦的目的。

.net项目开发系统设计

 

这里主要是:

业务逻辑层:

ICMSBLL:业务逻辑层接口

CMSBLL:业务逻辑层实现

抽象的数据底层封装(泛型)

ICommonSupportDAL:对公共的方法的抽象

CommonSupportDAL:公共方法的实现

数据访问层:

ICMSDAL:数据访问层接口

CMSDAL:数据访问层实现

领域模型层:

Entity:这是EF建立的模型

集合类层:

Collections:封装了分页,对于集合类内部的增删改查,对集合类内部类的增删改查。

界面层:

ComplaintManageSystem:主要的MVC和LigerUI实现的界面部分

TZHSWEET.UI:关于MVC公共UI定义的部分

公共类库部分:

我们的目标是“0”增删改查的数据访问层实现,主要是靠Nhibernate的定义通用的增删改从,然后其他类继承增删改查接口和相应的自定义的子类的接口,实现拓展

首先,我们从以前的写代码经验知道,我们的Dao主要是做增删改查等方面,我们就先定义一个公共方法的接口叫做ICommonSupportDAL,这个接口定义泛型增删改查。

  1. <span style="font-family:FangSong_GB2312;font-size:18px;">using System;

  2. using System.Collections.Generic;

  3. using System.Linq;

  4. using System.Text;

  5. using Entity;

  6. namespace ICommonSupportDAL

  7. {

  8.     public interface IRepository<T, TCollection> where T : class

  9.     {

  10.         #region 即时查询,通过ID查询

  11.         /// <summary>

  12.         /// 获取实体

  13.         /// </summary>

  14.         /// <param name="id">主键</param>

  15.         /// <returns>实体</returns>

  16.         T Get(object id);

  17.         #endregion

  18.         #region 延迟加载,通过ID查询

  19.         /// <summary>

  20.         /// 获取实体

  21.         /// </summary>

  22.         /// <param name="id">主键</param>

  23.         /// <returns>实体</returns>

  24.         T Load(T entity);

  25.         #endregion

  26.         #region 将数据持久化到数据库

  27.         /// <summary>

  28.         /// 插入实体

  29.         /// </summary>

  30.         /// <param name="entity">实体</param>

  31.         /// <returns>ID</returns>

  32.         object Save(T entity);

  33.         #endregion

  34.         #region 更新数据信息

  35.         /// <summary>

  36.         /// 修改实体

  37.         /// </summary>

  38.         /// <param name="entity">实体</param>

  39.         void Update(T entity);

  40.         #endregion

  41.         #region 若数据存在则修改信息,若不存在则插入 

  42.         /// <summary>

  43.         /// 若数据存在则修改信息,若不存在则插入 

  44.         /// </summary>

  45.         /// <param name="entity">实体</param>

  46.         void SaveOrUpdate(T entity);

  47.         #endregion

  48.         #region 删除实体

  49.         /// <summary>

  50.         /// 删除实体

  51.         /// </summary>

  52.         /// <param name="id">ID</param>

  53.         void Delete(T entity);

  54.         #endregion

  55.         #region 根据ID批量删除实体

  56.         //删除实体

  57.         //void Delete(T entity);

  58.         /// <summary>

  59.         /// 根据ID批量删除实体

  60.         /// </summary>

  61.         /// <param name="idList">ID集合</param>

  62.         void Delete(IList<T> idList);

  63.         #endregion

  64.         /// <summary>

  65.         /// 获取全部集合

  66.         /// </summary>

  67.         /// <returns>集合</returns>

  68.         //IQueryable<T> LoadAll();

  69.  
  70.         /// <summary>

  71.         /// 分页获取全部集合

  72.         /// </summary>

  73.         /// <param name="count">记录总数</param>

  74.         /// <param name="pageIndex">页码</param>

  75.         /// <param name="pageSize">每页大小</param>

  76.         /// <returns>集合</returns>

  77.         //IQueryable<T> LoadAllWithPage(out long count, int pageIndex, int pageSize);

  78.         #region 无条件查询所有实体(单表查询)

  79.         /// <summary>

  80.         /// 无条件查询所有实体(单表查询)

  81.         /// </summary>

  82.         /// <param name="sql"></param>

  83.         /// <returns></returns>

  84.         TCollection LoadAll();

  85.         #endregion

  86.         #region 通过自己写where条件查询实体

  87.         /// <summary>

  88.         /// 通过自己写where条件查询实体

  89.         /// </summary>

  90.         /// <param name="whereSql"></param>

  91.         /// <returns></returns>

  92.         TCollection LoadAllByWhereSql(object whereSql);

  93.         #endregion

  94.         #region 根据某一条件字段删除

  95.         /// <summary>

  96.         /// 按条件删除

  97.         /// </summary>

  98.         /// <param name="columName">字段名</param>

  99.         /// <param name="columValue">字段值</param>

  100.         void DeleteAfterQuery(object columName, object columValue);

  101.         #endregion

  102.         #region 按一个条件查询(单表查询)

  103.         /// <summary>

  104.         /// 按一个条件查询

  105.         /// </summary>

  106.         /// <param name="columnName"></param>

  107.         /// <param name="columValue"></param>

  108.         /// <returns></returns>

  109.         TCollection getByCondition(object columnName, object columValue);

  110.         #endregion

  111.         #region 通过原生sql语句进行增删改查操作

  112.         /// <summary>

  113.         /// 通过原生sql语句进行增删改查操作

  114.         /// </summary>

  115.         /// <param name="sql"></param>

  116.         /// <returns></returns>

  117.         TCollection ExecuteOrQueryBySql(object sql);

  118.         #endregion

  119.         #region 多条件查询

  120.         /// <summary>

  121.         /// 多条件查询

  122.         /// </summary>

  123.         /// <returns></returns>

  124.         TCollection FindVer(QueryHelper<T> qh);

  125.         #endregion

  126.         #region 根据SQL语句查询

  127.         /// <summary>

  128.        /// 根据SQL语句查询

  129.        /// </summary>

  130.        /// <param name="sql"></param>

  131.        /// <returns></returns>

  132.         TCollection LoadAllBySql(string sql);

  133.         #endregion

  134.         #region 根据某一字段查询(多表查询)

  135.         /// <summary>

  136.         /// 根据某一字段查询(多表查询)

  137.         /// </summary>

  138.         /// <param name="columnName"></param>

  139.         /// <param name="columValue"></param>

  140.         /// <returns></returns>

  141.         TCollection LoadByCondition(object columnName, object columValue);

  142.         #endregion

  143.     }

  144. }

  145.  
  146.  
  147. </span>

    这层接口,大家可能认为没什么必要,但是,这个接口非常重要,这个接口保证了我们用Nhibernate一个抽象类实现增删改查的同时又增加了子类的自身扩展性.

    接下来,就是Dao部分,我们需要很慎重的去设计,

    首先我们要设计一个用Nhibernate实现的公共父类的CommonSupportDAL类,用它来实现增删改查。

  1. <span style="font-family:FangSong_GB2312;font-size:18px;"><span style="color:#000000;">using System;

  2. using System.Collections.Generic;

  3. using System.Linq;

  4. using System.Text;

  5. using Spring.Data.NHibernate.Generic.Support;

  6. using NHibernate;

  7. using System.Linq.Expressions;

  8. using System.Collections;

  9. using ICommonSupportDAL;

  10. using Entity;

  11. using MCS.Library.Data.DataObjects;

  12. using System.Reflection;

  13. using Collections;

  14.  
  15. namespace CommonSupportDAL

  16. {

  17.  
  18.     /// <summary>

  19.     /// 数据访问层公共接口实现

  20.     /// </summary>

  21.     /// <typeparam name="T">实体泛型</typeparam>

  22.     public class RepositoryBase<T, TCollection> : HibernateDaoSupport, IRepository<T, TCollection>

  23.         where T : class

  24.         where TCollection : Collection<T, TCollection> ,new()

  25.     {

  26.  
  27.         public String TEntityName;

  28.         public RepositoryBase()

  29.         {

  30.             String name = typeof(T).ToString();

  31.             this.TEntityName = name.Substring(name.LastIndexOf('.') + 1);

  32.         }

  33.  
  34.  
  35.         #region 将实体持久化到数据库

  36.         /// <summary>

  37.         /// 将实体持久化到数据库

  38.         /// </summary>

  39.         /// <param name="entity">泛型实体</param>

  40.         /// <returns></returns>

  41.         public virtual object Save(T entity)

  42.         {

  43.            //  this.HibernateTemplate.Find<T>("from UserInfo ");

  44.             try

  45.             {

  46.                 this.HibernateTemplate.SessionFactory.GetCurrentSession().FlushMode = FlushMode.Auto;

  47.             }catch(Exception ex)

  48.                 {

  49.                 }

  50.             Object TEntity = this.HibernateTemplate.Save(entity);

  51.             this.HibernateTemplate.Flush();

  52.             return TEntity;

  53.  
  54.         }

  55.         #endregion

  56.         #region 根据ID查询

  57.         /// <summary>

  58.         /// 根据ID查询

  59.         /// </summary>

  60.         /// <param name="id"></param>

  61.         /// <returns></returns>

  62.         public virtual T Get(object id)

  63.         {

  64.  
  65.             return this.HibernateTemplate.Get<T>(id);

  66.  
  67.         }

  68.         #endregion

  69.         #region  根据ID查询

  70.         /// <summary>

  71.         /// 根据ID查询

  72.         /// </summary>

  73.         /// <param name="id">实体ID</param>

  74.         /// <returns></returns>

  75.         public virtual T Load(T entity)

  76.         {

  77.             Object fild=null;

  78.             try

  79.             {

  80.                  fild = entity.GetType().GetProperty("ID").GetValue(entity, null);

  81.             }

  82.             catch (Exception ex)

  83.             {

  84.                 string typename = entity.GetType().ToString();

  85.                 throw new Exception("请检查" + typename + "中是否存在主键ID!");

  86.             }

  87.             return this.HibernateTemplate.Load<T>(fild);

  88.  
  89.         }

  90.         #endregion

  91.         #region 查询所有实体信息

  92.         /// <summary>

  93.         /// 查询所有实体信息

  94.         /// </summary>

  95.         /// <returns></returns>

  96.         public virtual TCollection LoadAll()

  97.         {

  98.             TCollection tcollecton = new TCollection();

  99.             IList<T> list = this.HibernateTemplate.LoadAll<T>();

  100.             tcollecton.CopyFrom(list);

  101.             return tcollecton;

  102.  
  103.         }

  104.         #endregion

  105.         #region 根据条件查询实体集合信息(hql)

  106.         /// <summary>

  107.         /// 根据条件查询实体集合信息(hql)

  108.         /// </summary>

  109.         /// <returns></returns>

  110.         public virtual TCollection LoadAllByWhereSql(object whereSql)

  111.         {

  112.             TCollection tcollecton = new TCollection();

  113.             IList<T> list = this.HibernateTemplate.Find<T>("from " + TEntityName + "   where " + whereSql);

  114.             tcollecton.CopyFrom(list);

  115.             return tcollecton;

  116.  
  117.  
  118.         }

  119.         #endregion

  120.         #region 根据条件查询实体集合信息(sql)

  121.         /// <summary>

  122.         /// 根据条件查询实体集合信息(sql)

  123.         /// </summary>

  124.         /// <returns></returns>

  125.         public virtual TCollection LoadAllBySql(string sql)

  126.         {

  127.             TCollection tcollecton = new TCollection();

  128.             IList<T> list = this.HibernateTemplate.Find<T>(sql);

  129.             tcollecton.CopyFrom(list);

  130.             return tcollecton;

  131.  
  132.         }

  133.         #endregion

  134.         #region 更新实体信息

  135.         /// <summary>

  136.         /// 更新实体信息

  137.         /// </summary>

  138.         /// <param name="entity"></param>

  139.         public virtual void Update(T entity)

  140.         {

  141.             this.HibernateTemplate.SessionFactory.GetCurrentSession().FlushMode = FlushMode.Auto;

  142.             this.HibernateTemplate.Update(entity);

  143.             this.HibernateTemplate.Flush();

  144.         }

  145.         #endregion

  146.         #region 根据ID删除信息

  147.         /// <summary>

  148.         /// 根据ID删除信息

  149.         /// </summary>

  150.         /// <param name="id"></param>

  151.         public void Delete(T entity)

  152.         {

  153.             this.HibernateTemplate.SessionFactory.GetCurrentSession().FlushMode = FlushMode.Auto;

  154.             this.HibernateTemplate.Delete(entity);

  155.             this.HibernateTemplate.Flush();

  156.  
  157.         }

  158.  
  159.  
  160.         #endregion

  161.         #region 批量删除

  162.         /// <summary>

  163.         /// 批量删除

  164.         /// </summary>

  165.         /// <param name="idList"></param>

  166.         public virtual void Delete(IList<T> idList)

  167.         {

  168.  
  169.  
  170.              foreach (object item in idList)

  171.             {

  172.                 this.HibernateTemplate.SessionFactory.GetCurrentSession().FlushMode = FlushMode.Auto;

  173.                 this.HibernateTemplate.Delete(item);

  174.                 this.HibernateTemplate.Flush();

  175.  
  176.             }

  177.         }

  178.         #endregion

  179.  
  180.         #region 按条件删除

  181.         /// <summary>

  182.         ///按条件删除

  183.         /// </summary>

  184.         /// <param name="columName"></param>

  185.         /// <param name="columValue"></param>

  186.         public virtual void DeleteAfterQuery(object columName, object columValue)

  187.         {

  188.  
  189.             IList<T> list = this.HibernateTemplate.Find<T>("from " + TEntityName + "  u where u." + columName + " =?"new object[] { columValue });

  190.  
  191.             //在执行删除

  192.             foreach (object t in list)

  193.             {

  194.                 this.HibernateTemplate.SessionFactory.GetCurrentSession().FlushMode = FlushMode.Auto;

  195.                 this.HibernateTemplate.Delete(t);

  196.                 this.HibernateTemplate.Flush();

  197.  
  198.             }

  199.  
  200.  
  201.         }

  202.         #endregion

  203.         #region 保存后更新

  204.         /// <summary>

  205.         /// 保存后更新

  206.         /// </summary>

  207.         /// <param name="entity"></param>

  208.         public virtual void SaveOrUpdate(T entity)

  209.         {

  210.             this.HibernateTemplate.SessionFactory.GetCurrentSession().FlushMode = FlushMode.Auto;

  211.             this.HibernateTemplate.SaveOrUpdate(entity);

  212.             this.HibernateTemplate.Flush();

  213.         }

  214.         #endregion

  215.  
  216.  
  217.         //#region

  218.         ///// <summary>

  219.         ///// 根据条件查询实体集合信息--sql语句,不推荐使用,会产生sql注入

  220.         ///// </summary>

  221.         ///// <returns></returns>

  222.         //public virtual IList<T> getBywhereSql(string wheresql)

  223.         //{

  224.  
  225.         //    IList<T> list = this.HibernateTemplate.Find<T>("from " + TName + "   where " + wheresql);

  226.         //    return list;

  227.         //}

  228.         //#endregion

  229.  
  230.         //#region

  231.  
  232.         //#endregion

  233.         ///// <summary>

  234.         ///// 根据条件查询实体集合信息--sql语句,不推荐使用,会产生sql注入

  235.         ///// </summary>

  236.         ///// <returns></returns>

  237.         //public virtual IList<T> getBySql(string sql)

  238.         //{

  239.  
  240.         //    IList<T> list = this.HibernateTemplate.Find<T>(sql);

  241.         //    return list;

  242.         //}

  243.         #region 通过一个条件查询(单表查询)

  244.         /// <summary>

  245.         /// 通过一个条件查询(单表查询)

  246.         /// </summary>

  247.         /// <param name="columName">属性名</param>

  248.         /// <param name="columValue">属性值</param>

  249.         /// <returns></returns>

  250.         public virtual TCollection getByCondition(object columnName, object columValue)

  251.         {

  252.             TCollection tcoll = new TCollection();

  253.             //比如验证用户名,只需要传入Name属性的名称和值即可;

  254.             //这个Name是对应的实体的属性名称,非数据库字段名。例getByCondition("Name","11");

  255.             IList<T> list = this.HibernateTemplate.Find<T>("from " + TEntityName + "  u where u." + columnName + " =?"new object[] { columValue });

  256.             tcoll.CopyFrom(list);

  257.             return tcoll;

  258.         }

  259.         #endregion

  260.         #region 通过一个条件查询(多表查询)

  261.         /// <summary>

  262.         /// 通过一个条件查询(单表查询)

  263.         /// </summary>

  264.         /// <param name="columName">属性名</param>

  265.         /// <param name="columValue">属性值</param>

  266.         /// <returns></returns>

  267.         public virtual TCollection LoadByCondition(object columnName, object columValue)

  268.         {

  269.             TCollection tcoll = new TCollection();

  270.             //比如验证用户名,只需要传入Name属性的名称和值即可;

  271.             //这个Name是对应的实体的属性名称,非数据库字段名。例getByCondition("Name","11");

  272.             IList<T> list = this.HibernateTemplate.Find<T>("from " + TEntityName + "  u where u." + columnName + " =?"new object[] { columValue });

  273.             tcoll=this.LoadById(list);

  274.             return tcoll;

  275.         }

  276.         #endregion

  277.         #region 通过原生sql语句进行增删改查操作

  278.         /// <summary>

  279.         /// 通过原生sql语句进行增删改查操作

  280.         /// </summary>

  281.         /// <param name="sql"></param>

  282.         /// <returns></returns>

  283.         public TCollection ExecuteOrQueryBySql(object sql)

  284.         {

  285.             TCollection tcollecton = new TCollection();

  286.             ISQLQuery sqlQuery = this.HibernateTemplate.SessionFactory.GetCurrentSession().CreateSQLQuery(sql.ToString()).AddEntity(typeof(T));

  287.              tcollecton.CopyFrom(sqlQuery.List<T>());

  288.              return tcollecton;

  289.         }

  290.         #endregion

  291.         #region 多条件查询

  292.         /// <summary>

  293.         /// 多条件查询

  294.         /// </summary>

  295.         /// <returns></returns>

  296.         public TCollection FindVer(QueryHelper<T> qh)

  297.         {

  298.             // QueryHelper<T> qh = new QueryHelper<T>("u");

  299.             //return qh;

  300.  
  301.             // 参数列表

  302.             IList<Object> parameters = qh.getParameters();

  303.  
  304.             // 查询本页的数据列表

  305.             IQuery listQuery = this.HibernateTemplate.SessionFactory.GetCurrentSession().CreateQuery(qh.getListQueryHql()); // 创建查询对象

  306.             if (parameters != null)

  307.             { // 设置参数

  308.                 for (int i = 0; i < parameters.Count; i++)

  309.                 {

  310.                     listQuery.SetParameter(i, parameters[i]);

  311.                 }

  312.             }

  313.  
  314.             listQuery.List();

  315.             TCollection tcollection = new TCollection();

  316.             IList<T> list = listQuery.List<T>();

  317.             tcollection.CopyFrom(list);

  318.             return tcollection;

  319.         }

  320.         #endregion

  321.         #region 分页查询

  322.         /// <summary>

  323.         /// 分页查询

  324.         /// </summary>

  325.         /// <param name="tcollection"></param>

  326.         /// <returns></returns>

  327.         public TCollection LoadAllByPage(TCollection tcollection)

  328.         {

  329.  
  330.           IQuery query = this.HibernateTemplate.SessionFactory.OpenSession().CreateQuery("from "+typeof(T).ToString());

  331.           query.SetFirstResult((tcollection.PageNum - 1) * tcollection.PageSize);

  332.           query.SetMaxResults(tcollection.PageSize);

  333.           IList list = query.List();

  334.           TCollection tcoll = new TCollection();

  335.           tcoll.TotalRecords=this.LoadAll().Count();

  336.           IEnumerator en = list.GetEnumerator();

  337.           while (en.MoveNext())

  338.           {

  339.               tcoll.Add((T)en.Current);

  340.           }

  341.           //tcoll.CopyFrom(list);

  342.          return tcoll;

  343.         }

  344.         #endregion

  345.         #region 通过多个ID查询

  346.         /// <summary>

  347.         /// 通过多个ID查询

  348.         /// </summary>

  349.         /// <param name="entity">包含ID信息的实体集合</param>

  350.         /// <returns>集合信息</returns>

  351.        public TCollection LoadById(IList<T> entity) {

  352.            IEnumerator en = entity.GetEnumerator();

  353.            IList<object> IDlist = new List<object>();

  354.            while (en.MoveNext())

  355.            {

  356.                Object fild = null;

  357.                try

  358.                {

  359.                    fild = en.Current.GetType().GetProperty("ID").GetValue(en.Current, null);

  360.                }

  361.                catch (Exception ex)

  362.                {

  363.                    string typename = en.Current.GetType().ToString();

  364.                    throw new Exception("请检查" + typename + "中是否存在主键ID!");

  365.                }

  366.  
  367.                IDlist.Add("'"+fild+"'");

  368.            }

  369.  
  370.            IQuery query = this.HibernateTemplate.SessionFactory.OpenSession().CreateQuery("from " + TEntityName + " u where u.ID in (" +string.Join(",",IDlist.ToArray())+")");

  371.          //  IQuery query = this.HibernateTemplate.SessionFactory.OpenSession().CreateQuery("from " + TEntityName + " u where u.ID in ('05221ff5-b491-4590-86bb-f5e275c6fd83','10df07ac-98ae-41f8-bcde-c4f48ec931f4','14c33f83-3be7-4162-8ace-8ef2e3677402','29780cc4-d7d8-4982-b8b7-ee63320da1d8','299ad880-06e3-48a3-80ca-570b8a557c42','7662b072-42a7-45fc-b11b-93efc844e5cd','87c26a14-56f2-4a57-9c99-e55f55ba6cdd','87c73291-591b-431f-b0fe-e73e15a490cf','917f9354-29e2-44b0-ad58-e2d8a0dd7670','9de57d2d-b4f8-4c56-9ce6-66673f42413d','a0e0cb9a-e8e4-4164-a021-cbcb61a8ea30','c6c239bf-6089-4c7c-983c-8ca479c360d5','c996d768-c9f9-4575-9268-4cfcf92fd038','ca09c55e-0a8d-4241-a364-74f1bdb60c32','da34ebae-11a7-4cfc-9772-b5e049768fe7','e5ee288e-8c5d-46bc-8c77-34b8c45750c1')");

  372.  
  373.  
  374.             IList list=  query.List();

  375.           TCollection tc= new TCollection();

  376.            IEnumerator enumer=list.GetEnumerator();

  377.            while(enumer.MoveNext())

  378.            {

  379.               tc.Add((T)enumer.Current);

  380.            }

  381.            return tc;

  382.         }

  383.         #endregion

  384.     }

  385.  
  386.  
  387.  
  388. }</span>

  389. </span>

 

接下来我们的工作量就小了,我们可以看到成果了,我们接下来的实现,只需要继承上面这个RepositoryBase和IRepository的部分就可以很轻松的实现,子类的增删改查以及子类的扩展了.

  1. <span style="font-family:FangSong_GB2312;font-size:18px;"><span style="color:#000000;">  public interface ICaseAssignEntityRepository:IRepository<CaseAssignEntity,CaseAssignEntityCollection>

  2.     {

  3.     }</span></span>

 

  1. <span style="font-family:FangSong_GB2312;font-size:18px;">namespace CMSDAL.AnJianLuRu

  2. {

  3.     public class CaseAssignEntityRepository : RepositoryBase<CaseAssignEntity, CaseAssignEntityCollection>, ICaseAssignEntityRepository

  4.     {

  5.     }

  6. }</span>

大家看到继承了两个一个是RepositoryBase父类,一个是ICaseAssignEntityRepository自己的业务逻辑接口(实现了子类的拓展,比如在某个类中想要添加这个类特有的方法,只需要在自己的接口中填写即可),通过这个继承体系保证了我们在实现增删改查的同时外放一个接口保证扩展性.

继承系列图:

总结

     这样我们的数据访问层,很轻松的实现了,基本上代码量非常少,增删改查部分几乎"0"代码,都是泛型的父类实现了.抽象、继承、泛型、委托、容器等等大大提高了代码的复用性。-----一切来源于抽象!以上这部分.net项目开发的架构算是基本成型,后面可以进行相关编码工作。