接着上一篇关于分层架构的讨论，一个分层架构设计的例子（1）。
上篇介绍了实体类（Entity）、数据库访问类（DAL）、数据访问接口（IDAL）的相关设计，本篇主要讨论下面几个部分内容：业务逻辑层、缓存机制、界面层等方面。
业务逻辑层，主要是业务逻辑基类的设计，由于数据库访问类（DAL）的基类封装了大量的操作实现，因此，业务逻辑层的主要工作是进一步封装对底层访问接口的实现，如下所示。

    public class BaseBLL<T> where T : BaseEntity, new()

    

{

        构造函数#region 构造函数

        private string dalName = "";

        protected IBaseDAL<T> baseDal = null;

        public BaseBLL()

            : this("")

        

{

        }

        public BaseBLL(string dalName)

        

{

            this.dalName = dalName;

            if (string.IsNullOrEmpty(dalName))

            

{

                this.dalName = GetType().Name;

            }

            baseDal = Reflect<IBaseDAL<T>>.Create(this.dalName, "HuaweiSoftware.IPSPBD.DAL");

        } 

        #endregion

        对象添加、修改、删除等接口#region 对象添加、修改、删除等接口

        /**//// <summary>

        /// 插入指定对象到数据库中

        /// </summary>

        /// <param name="obj">指定的对象</param>

        /// <returns>执行成功返回新增记录的自增长ID。</returns>

        public virtual bool Insert(T obj)

        

{

            return baseDal.Insert(obj);

        }

        /**//// <summary>

        /// 更新对象属性到数据库中

        /// </summary>

        /// <param name="obj">指定的对象</param>

        /// <returns>执行成功返回<c>true</c>，否则为<c>false</c>。</returns>

        public virtual bool Update(T obj, string primaryKeyValue)

        

{

            return baseDal.Update(obj, primaryKeyValue);

        }

        /**//// <summary>

        /// 查询数据库,检查是否存在指定ID的对象(用于字符型主键)

        /// </summary>

        /// <param name="key">对象的ID值</param>

        /// <returns>存在则返回指定的对象,否则返回Null</returns>

        public virtual T FindByID(string key)

        

{

            return baseDal.FindByID(key);

        }

        /**//// <summary>

        /// 查询数据库,检查是否存在指定键值的对象

        /// </summary>

        /// <param name="fieldName">指定的属性名</param>

        /// <param name="key">指定的值</param>

        /// <returns>存在则返回<c>true</c>，否则为<c>false</c>。</returns>

        public virtual bool IsExistKey(string fieldName, object key)

        

{

            return baseDal.IsExistKey(fieldName, key);

        }

        /**//// <summary>

        /// 根据指定对象的ID,从数据库中删除指定对象(用于整型主键)

        /// </summary>

        /// <param name="key">指定对象的ID</param>

        /// <returns>执行成功返回<c>true</c>，否则为<c>false</c>。</returns>

        public virtual bool Delete(string key)

        

{

            return baseDal.DeleteByKey(key);

        }

        /**//// <summary>

        /// 根据指定条件,从数据库中删除指定对象

        /// </summary>

        /// <param name="condition">删除记录的条件语句</param>

        /// <returns>执行成功返回<c>true</c>，否则为<c>false</c>。</returns>

        public virtual bool DeleteByCondition(string condition)

        

{

            return baseDal.DeleteByCondition(condition);

        }

        #endregion

        返回集合的接口#region 返回集合的接口

        /**//// <summary>

        /// 根据ID字符串(逗号分隔)获取对象列表

        /// </summary>

        /// <param name="idString">ID字符串(逗号分隔)</param>

        /// <returns>符合条件的对象列表</returns>

        public virtual List<T> FindByIDs(string idString)

        

{

            return baseDal.FindByIDs(idString);

        }

        /**//// <summary>

        /// 根据条件查询数据库,并返回对象集合

        /// </summary>

        /// <param name="condition">查询的条件</param>

        /// <returns>指定对象的集合</returns>

        public virtual List<T> Find(string condition)

        

{

            return Find(condition);

        }

        /**//// <summary>

        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)

        /// </summary>

        /// <param name="condition">查询的条件</param>

        /// <param name="info">分页实体</param>

        /// <returns>指定对象的集合</returns>

        public virtual List<T> Find(string condition, PagerInfo info)

        

{

            return baseDal.Find(condition, info);

        }

        /**//// <summary>

        /// 返回数据库所有的对象集合

        /// </summary>

        /// <returns>指定对象的集合</returns>

        public virtual List<T> GetAll()

        

{

            return baseDal.GetAll();

        }

        /**//// <summary>

        /// 返回数据库所有的对象集合(用于分页数据显示)

        /// </summary>

        /// <param name="info">分页实体信息</param>

        /// <returns>指定对象的集合</returns>

        public virtual List<T> GetAll(PagerInfo info)

        

{

            return baseDal.GetAll(info);

        }

        public virtual DataSet GetAllToDataSet(PagerInfo info)

        

{

            return baseDal.GetAllToDataSet(info);

        }

        #endregion

    }

业务层基类封装了大量的调用，那么对于业务层的具体操作类，它的工作就很简单了，基本上只需要继承一下基类就可以了，这就是有一个优秀父亲的好处，呵呵

    public class Equipment : BaseBLL<EquipmentInfo>

    

{

        public Equipment() : base()

        

{

        }

    }

基本上，业务层的设计到此应该收尾了，可是我们注意到，很多开发都使用了缓存的机制来进一步提高程序的性能，下面对这方面进行讨论。缓存的机制，一般是把创建过的对象资源放到一个集合中，需要的时候，调出来，如下业务层的工厂类所示。

    public class BLLFactory<T> where T : class

    

{

        private static Hashtable objCache = new Hashtable();

        public static T Instance

        

{

            get

            

{

                string CacheKey = typeof(T).FullName;

                T bll = (T)objCache[CacheKey];　 //从缓存读取  

                if (bll == null)

                

{

                    bll = Reflect<T>.Create(typeof(T).Name, "HuaweiSoftware.IPSPBD.BLL"); //反射创建，并缓存

                }

                return bll;

            }

        }

    }  

这是一个业务逻辑类工厂创建类，我们在界面层只需要如下调用即可构造一个（利用了缓存）具体的业务类出来

CustomerInfo info = BLLFactory<Customer>.Instance.FindByID(ID);

在上面的BaseBLL和BLLFactory类中，有一个Reflect的操作类，这是反射缓存的具体实现所在，我们探讨一下它的实现。

    public class Reflect<T> where T : class 

    

{

        private static Hashtable m_objCache = null;

        public static Hashtable ObjCache

        

{

            get

            

{

                if (m_objCache == null)

                

{

                    m_objCache = new Hashtable();

                }

                return m_objCache;

            }

        }

        public static T Create(string sName, string sFilePath)

        

{

            return Create(sName, sFilePath, true);

        }

        public static T Create(string sName, string sFilePath, bool bCache)

        

{

            string CacheKey = sFilePath + "." + sName;

            T objType = null;

            if (bCache)

            

{

                objType = (T)ObjCache[CacheKey];    //从缓存读取 

                if (!ObjCache.ContainsKey(CacheKey))

                

{

                    Assembly assObj = CreateAssembly(sFilePath);

                    object obj = assObj.CreateInstance(CacheKey);

                    objType = (T)obj;

                    ObjCache.Add(CacheKey, objType);// 写入缓存 将DAL内某个对象装入缓存

                }

            }

            else

            

{

                objType = (T)CreateAssembly(sFilePath).CreateInstance(CacheKey); //反射创建 

            }

            return objType;

        }

        public static Assembly CreateAssembly(string sFilePath)

        

{

            Assembly assObj = (Assembly)ObjCache[sFilePath];

            if (assObj == null)

            

{

                assObj = Assembly.Load(sFilePath);

                ObjCache.Add(sFilePath, assObj);//将整个DLL装入缓存

            }

            return assObj;

        }

    }

另外，如果你在业务层需要实现更加复杂的功能，而数据库访问基类BaseDAL提供的函数不能满足你的需要，可以扩展数据访问层的接口和实现，如下所示。

    public interface ICustomer : IBaseDAL<CustomerInfo>

    

{

        List<string> GetAllCustomerNumber();

        CustomerInfo GetByCustomerNumber(string number);

    }

    public class Customer : BaseDAL<CustomerInfo>, ICustomer

    

{

        对象实例及构造函数#region 对象实例及构造函数

        public static Customer Instance

        

{

            get

            

{

                return new Customer();

            }

        }

        public Customer() : base("All_Customer","ID")

        

{

        }

        #endregion

        

        ICustomer 成员#region ICustomer 成员

        public List<string> GetAllCustomerNumber()

        

{

            string sql = string.Format("Select Number From dbo.{0}", tableName);

            List<string> list = new List<string>();

            Database db = DatabaseFactory.CreateDatabase();

            DbCommand command = db.GetSqlStringCommand(sql);

            string number = string.Empty;

            using (IDataReader dr = db.ExecuteReader(command))

            

{

                while (dr.Read())

                

{

                    number = dr["Number"].ToString();

                    if (!string.IsNullOrEmpty(number))

                    

{

                        list.Add(number);

                    }

                }

            }

            return list;

        }

        

        public CustomerInfo GetByCustomerNumber(string number)

        

{

            string condition = string.Format("Number = '{0}'", number);

            List<CustomerInfo> list = base.Find(condition);

            if (list.Count > 0)

            

{

                return list[0];

            }

            else

            

{

                return null;

            }

        }

        #endregion

    }

那么在业务层的类修改如下

    public class Customer : BaseBLL<CustomerInfo>

    

{

        public Customer() : base()

        

{

        }

        public List<string> GetAllCustomerNumber()

        

{

            ICustomer customerDAL = baseDal as ICustomer;

            return customerDAL.GetAllCustomerNumber();

        }

        public CustomerInfo GetByCustomerNumber(string number)

        

{

            ICustomer customerDAL = baseDal as ICustomer;

            return customerDAL.GetByCustomerNumber(number);

        }

    }

最后，界面方面的设计是见仁见智，但根本一条是利用一些控件，可以统一风格，减少劳动，给出几个界面的设计截图供大家参考
WinForm方面的(颜色标明的是使用了特定的界面控件，其中红色部分为和整个架构整合起来的分页控件，集成了一些基本的右键菜单操作，包括打印功能、数据导出功能等)：

Winform分页控件设计视图

可以选择列进行打印

在实际运用过程中的界面效果

WebForm方面的（可以使用之前文章介绍的查询控件、分页控件、内容编辑控件）：

下图是查询控件和分页控件的一起运用：

修改内容时候的编辑控件

查看内容时候的编辑控件

以上所引用的代码是通过代码生成工具Database2Sharp自动生成（http://www.iqidi.com/Database2Sharp.htm），选择EnterpriseLibrary架构即可。