业务逻辑层BLL实现过程

    业务类使用DAL类提供对数据的访问，并加强验证规则，约束检查，并且提供数据的面向对象的表达方式和用于处理数据的方法。这样，BLL作为了一个映射层，它使得底层关系数据库中的数据在用户界面的代码中以对象的方式出现。

承接上文：DAL层代码实现

先来回顾：DAL中的实体类对象：User类和Department类

DAL中的实体类： 它们只是将从数据库中取得的数据象征性地进行封装，与数据库的表(或者视图)是一一对应的关系，

没有对数据进行插入、更新、删除和检索的方法。

 

建立BLL文件夹，里面存放的是业务域对象。下图是域对象DepartmentObj的类图。

这种类要复杂些，不但要封装数据，还要有对其父对象或子对象进行引用的其他属性(如DepartmentObj的属性AllUserObjs<表示该部门下的所有员工集合>;UserObj的属性DepartmentObj<表示该员工所属的部门信息>)，还要有操作数据的实例方法<这些实例方法把工作委托给该类中各自对应的静态方法(如DeleteUserObj、UpdateUserObj等静态方法)>。(DepartmentObj/UserObj的Delete方法/Update方法)。

 

这种类通常称为域对象(domain object)，而不仅仅是上面的实体类。虽然创建起来更复杂，但是能更好的将数据库结构抽象化，UI开发人员使用起来更直观。

域对象也比较容易维护，能更快地从数据库中载入数据，并且占用较少的内存，这是由于它利用了安需载入数据模式(lazy-load)，只载入需要的数据，而不是将单个查询得到的所有内容同时载入。还可以为域对象增加自定义验证逻辑，因为数据是封装在能够充分按照自己所需要的逻辑来进行扩展的属性当中。

对应的代码如下：

DepartmentObj代码：

using System;
using System.Collections.Generic;
using System.Text;
using 抽象工厂模式.DAL.Provider;
using 抽象工厂模式.DAL.Entity;

namespace 抽象工厂模式.BLL
{
   public class DepartmentObj
    {
       public DepartmentObj() { }
       public DepartmentObj(int id, string name, string desc)
        {
            this.Id = id;
            this.Name = name;
            this.Desc = desc;
        }

        private int _id=0;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }
        private string _name="";
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private string _desc="";//部门描述
        public string Desc
        {
            get { return _desc; }
            set { _desc = value; }
        }

        private List<UserObj> _allUserObjs = null;
        public List<UserObj> AllUserObjs
        {
            get {
                if (_allUserObjs == null)
                    _allUserObjs = UserObj.GetUsers(this.Id);//按需载入(lazy load)模式
                return _allUserObjs;

            }
        }

        private static DepartmentObj GetDepartmentObjFromDepartment(Department record)
        {
            if (record == null) return null;
            return new DepartmentObj(record.Id, record.Name, record.Desc);
        }
        private static List<DepartmentObj> GetDepartmentObjListFromDepartmentList(List<Department> recordset)
        {
            List<DepartmentObj> results = new List<DepartmentObj>();
            foreach(Department record in recordset)
                results.Add(GetDepartmentObjFromDepartment(record));
            return results;
        }
        public static DepartmentObj GetDepartmentById(int id)
        {
           Department record= DepartmentProvider.Instance.GetDepartmentById(id);
           return GetDepartmentObjFromDepartment(record);
        }
        public static List<DepartmentObj> GetDepartments()
        {
            return GetDepartmentObjListFromDepartmentList( DepartmentProvider.Instance.GetDepartments());
        }
        public static bool DeleteDepartmentObj(int id)
        {return DepartmentProvider.Instance.DeleteDepartment(id);}
        public static bool UpdateDepartmentObj(int id,string name,string desc)
        {
            return DepartmentProvider.Instance.UpdateDepartment(new Department(id,name,desc));
        }
        public static int InsertDepartmentObj(string name,string desc)
        {
            return DepartmentProvider.Instance.InsertDepartment(new Department(0,name,desc));
        }

        public bool Delete()
        { bool success = DepartmentObj.DeleteDepartmentObj(this.Id); if (success) this.Id = 0; return success; }
        public bool Update()
        {
            return DepartmentObj.UpdateDepartmentObj(this.Id, this.Name, this.Desc);
        }
    }
}

 

UserObj.cs代码：

using System.Collections.Generic;
using System.Text;
using 抽象工厂模式.DAL.Entity;
using 抽象工厂模式.DAL.Provider;

namespace 抽象工厂模式.BLL
{
   public class UserObj
    {
       public UserObj(){}
       public UserObj(int id, string name, int deptId, string deptTitle)
       {
           this.Id = id;
           this.Name = name;
           this.DeptId = deptId;
           this.DeptTitle = deptTitle; 
       }
       private DepartmentObj _departmentObj = null;
       public DepartmentObj DepartmentObj
       {
           get {
               if (_departmentObj == null)
                   _departmentObj = DepartmentObj.GetDepartmentById(this.Id);//按需载入(lazy load)模式
               return _departmentObj;
           }
       }
        private int _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private int _deptId;
        public int DeptId
        {
            get { return _deptId; }
            set { _deptId = value; }
        }

        private string _deptTitle;
        public string DeptTitle
        {
            get { return _deptTitle; }
            set { _deptTitle = value; }
        }

        private static UserObj GetUserObjFromUser(User record)
        {
            if (record == null) return null;
            return new UserObj(record.Id, record.Name, record.DeptId, record.DeptTitle);
        }
        private static List<UserObj> GetUserObjListFromUserList(List<User> recordset)
        {
            List<UserObj> results = new List<UserObj>();
            foreach (User record in recordset)
                results.Add(GetUserObjFromUser(record));
            return results;
        }
        public static List<UserObj> GetUsers()
        {
            return GetUserObjListFromUserList( UserProvider.Instance.GetUsers() );
        }
        public static List<UserObj> GetUsers(int deptId)
        {
            return GetUserObjListFromUserList(UserProvider.Instance.GetUsers(deptId));
        }
        public static UserObj GetUserById(int id)
        {
            return GetUserObjFromUser(UserProvider.Instance.GetUserById(id));
        }
        public static bool UpdateUserObj(int id, string name, int deptId)
        {
           return  UserProvider.Instance.UpdateUser(new User(id, name, deptId, ""));
        }
        public static int InsertUserObj(int deptId, string name)
        {
            return UserProvider.Instance.InsertUser(new User(0, name, deptId, ""));
        }
        public static bool DeleteUserObj(int id)
        {
            return UserProvider.Instance.DeleteUser(id);
        }

        public bool Delete() { bool success = DeleteUserObj(this.Id); if (success) this.Id = 0; return success; }
        public bool Update() { return UpdateUserObj(this.Id, this.Name, this.DeptId); }
    }
}

 

 

 

进行测试：报错误，提示无法访问，检查发现：

很明显，忘记调用reader.Read()方法了，当使用DbDataReader对象的时候，千万不要忘记Read()方法的调用。

改动如下：

public override Department GetDepartmentById(int id)
        {
            using (OleDbConnection conn = new OleDbConnection(ConnString))
            {
                var dbCommand = conn.CreateCommand();
                dbCommand.CommandText = 
                    "select id,[name],[desc] from department where id="+id;
                conn.Open();

                var reader = dbCommand.ExecuteReader();
                if (reader.Read())
                    return GetDepartmentFromReader(reader);
                else
                    return null;
            }
        }

其它地方对应改动，然后我们在看看lazy-mode模式的好处。

见图可知：窗体加载事件中的第一行代码：不会调用访问每个UserObj对象的属性DepartmentObj，但是当DataGridView控件呈现的时候会遍历UserObj对象的每个属性，自然访问了DepartmentObj属性，从而引起按需载入。<请注意：在UserObj的构造函数中：并没有对属性DepartmentObj进行读取。>

运行看断点执行情况：

接着F9，继续运行：

可见GridView显示每一行记录时，都会执行断点处代码：

最后显示：

当然，可以投机取巧一下（DataGridView显示的"抽象工厂模式.BLL.DepartmentObj"实际上是访问该对象的ToStriing()方法获取的。因为：基类Object有此虚拟方法），改写一下：

public class DepartmentObj
    {
       public override string ToString()
       {
           //return base.ToString();
           return Name;
       }