C# 权限管理方案

最新推荐文章于 2024-06-15 22:41:24 发布
最新推荐文章于 2024-06-15 22:41:24 发布
阅读量5.4k 收藏 46
点赞数 4
分类专栏： C#

一、建立 SQL Server 数据库模型

 1、原始方案


  一共设立了五个实体模型：
 
  A、操作员（Operator）：存储系统登录用户的名称、密码、启用状态等信息。
  B、权限组（RightsGroup）：存储系统权限分组（即：权限角色）的名称等信息。
  C、权限关系（RightsRelation）：用于将A项和B项之间的多对多关系拆解成两个一对多关系。
  D、权限列表（RightsList）：存储系统菜单项（即：权限项）的标题、内部名称、权限状态等信息。
  E、权限组关系（RightGroupRelation）：用于将B项和D项之间的多对多关系拆解成两个一对多关系。
  
  通过上面的描述可以清楚看到，C项和E项仅仅是为了拆解多对多关系而设立，实体关系变得相对复杂了点。稍作考虑便知，既然是使用 C# WinForm + SQL Server 来完成这一功能，则可以考虑使用实体类来模拟数据库模型，并将实体类打包成泛型集合后存储到 SQL Server 数据库的 varBinary(max) 字段。这样便可以将原始方案的数据库模型缩减成三个实体模型，降低了关系的复杂程度。将原始方案稍作修改后即可得到如下改进方案。
 
 2、改进方案
  
  如上所述，改进后的方案仅包含如下三个实体模型：
  
  A、操作员（Operator）：存储系统登录用户的名称、密码、启用状态、权限集合等信息。
  B、权限组（RightsGroup）：存储系统权限分组（即：权限角色）的名称、权限集合等信息。
  C、权限关系（RightsRelation）：用于将A项和B项之间的多对多关系拆解成两个一对多关系。
  
  很容易看出，仅将原始方案的 E 项更改为 A项和 B 项的字段，即可将实体关系复杂度降低 40%。现在我们来看看改进方案的 SQL Server 数据库实现脚本代码：
 

-- 判断是否存在 操作员信息表（Operator），如果存在，则删除表 Operator
   if exists(Select * From SysObjects Where Name = 'Operator')
    Drop Table [Operator]
   Go 

   -- 创建 操作员信息表（Operator）
   Create Table [Operator]
   (
    -- 主键列，自动增长 标识种子为 1 
    [Id] int identity(1,1) Constraint [PK_OperatorId] Primary Key,

    -- 操作员姓名
    [OperatorName] nVarChar(50) Constraint [UQ_OperatorName] Unique(OperatorName) Not Null,

    -- 密码
    [Password] nVarChar(50) Constraint [CK_Password] Check(len([Password])>=6) Not Null,

    -- 操作员权限列表
    [RightsList] varBinary(max) Null,

    -- 用户当前状态
    [State] bit Constraint [DF_State] Default('true') Constraint [CK_State] Check([State] in ('true','false')) Not Null,
   )
   Go

   -- 判断是否存在 权限组信息表（RightsGroup），如果存在，则删除表 RightsGroup
   if exists(Select * From SysObjects Where Name = 'RightsGroup')
    Drop Table [RightsGroup]
   Go 

   -- 创建 权限组信息表（RightsGroup）
   Create Table [RightsGroup]
   (
    -- 主键列，自动增长 标识种子为 1 
    [Id] int Identity(1,1) Constraint [PK_RightsGroupId] Primary Key,
    
    -- 权限组名称
    [GroupName] nVarChar(50) Constraint[UQ_GroupName] Unique (GroupName) Not Null,

    -- 组权限列表
    [GroupRightsList] varBinary(max) Null,
   )
   Go

   -- 判断是否存在权限关系表（RightsRelation），如果存在，则删除表 RightsRelation
   if exists(Select * From SysObjects Where Name = 'RightsRelation')
    drop table [RightsRelation]
   Go

   -- 创建 权限关系表（RightsRelation）
   Create Table [RightsRelation]
   (
    -- 主键列，自动增长 标识种子为 1 
    [Id] int Identity(1, 1) Constraint [PK_RightsRelationId] Primary Key,

    -- 操作员 Id
    [OperatorId] int Constraint [FK_OperatorId] Foreign Key References Operator([Id]) Not Null,
    
    -- 权限组 Id
    [RightsGroupId] int Constraint [FK_RightsGroupId] Foreign Key References RightsGroup([Id]) Not Null
   )
   Go

二、建立实体类

 建立了 SQL Server 数据库模型之后，我们开始建立实体类来作为权限管理的数据传输载体。
 
 1、实体模型基类（ModelBase）
 
  C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;

namespace CodingMouse.CMHotelManager.Model
{
    /// <summary>
    ///  实体模型基类
    /// </summary>
    [Serializable]
    public class ModelBase

    {
        #region Private Members

        int _id;
        string _modelName;

        #endregion

        #region Public Properties

        /// <summary>
        /// 实体模型 ID
        /// </summary>
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        /// <summary>
        /// 实体模型名称
        /// </summary>
        public string ModelName
        {
            get { return _modelName; }
            set { _modelName = value; }
        }
        #endregion

        #region Public Methods

        /// <summary>
        /// 无参构造
        /// </summary>
        public ModelBase() { } 

        /// <summary>
        /// 带参构造
        /// </summary>
        /// <param name="id">实体模型 ID</param>
        /// <param name="modelName">实体模型名称</param>
        public ModelBase(int id, string modelName)
        {
            this.Id = id;
            this.ModelName = modelName;
        }
        #endregion
    }
}

 2、操作员实体类（Operator）
 
  C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;

namespace CodingMouse.CMHotelManager.Model
{
    /// <summary>
    /// 操作员实体类
    /// </summary>
    [Serializable]
    public class Operator : ModelBase
    {
        #region Private Members

        string _password;

        Dictionary<string, Rights> _rightsCollection;
        bool _state;

        #endregion

        #region Public Properties

        /// <summary>
        /// 操作员密码
        /// </summary>
        public string Password
        {
            get { return _password; }
            set { _password = value; }
        }

        /// <summary>
        /// 权限集合(键值用于存储菜单/工具栏项的 Name 属性)
        /// </summary>
        public Dictionary<string, Rights> RightsCollection
        {
            get { return _rightsCollection; }
            set { _rightsCollection = value; }
        }

        /// <summary>
        /// 操作员状态
        /// </summary>
        public bool State
        {
            get { return _state; }
            set { _state = value; }
        }
        #endregion

        #region Public Methods

        /// <summary>
        /// 无参构造(基类属性赋值说明：Id - 操作员 ID / ModelName - 操作员名称)
        /// </summary>
        public Operator() { }

        /// <summary>
        /// 带参构造
        /// </summary>
        /// <param name="operatorId">操作员 ID</param>
        /// <param name="name">操作员名称</param>
        /// <param name="password">操作员密码</param>
        /// <param name="rightsCollection">权限集合(键值用于存储菜单/工具栏项的 Name 属性)</param>
        /// <param name="state">操作员状态</param>
        public Operator(
        int operatorId,
        string name,
        string password,
        Dictionary<string, Rights> rightsCollection, bool state) : base(operatorId, name)
        {
            this.Password = password;
            this.RightsCollection = rightsCollection;
            this.State = state;
        }
        #endregion
    }
}

 3、权限组实体类（RightsGroup）
 
  C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;

namespace CodingMouse.CMHotelManager.Model
{
    /// <summary>
    /// 权限组实体类
    /// </summary>
    [Serializable]
    public class RightsGroup : ModelBase
    {
        #region Private Members

        Dictionary<string, Rights> _groupRightsCollection;

        #endregion

        #region Public Properties

        /// <summary>
        /// 组权限集合
        /// </summary>
        public Dictionary<string, Rights> GroupRightsCollection
        {
            get { return _groupRightsCollection; }
            set { _groupRightsCollection = value; }
        }
        #endregion

        #region Public Methods

        /// <summary>
        /// 无参构造(基类属性赋值说明：Id - 权限组 ID / ModelName - 权限组名称)
        /// </summary>
        public RightsGroup() { }

        /// <summary>
        ///  带参构造
        /// </summary>
        /// <param name="groupId">权限组 ID</param>
        /// <param name="groupName">权限组名称</param>
        /// <param name="groupRightsCollection">组权限集合</param>
        public RightsGroup(
        int groupId,
        string groupName,
        Dictionary<string, Rights> groupRightsCollection) : base(groupId, groupName)
        {
            this.GroupRightsCollection = groupRightsCollection;
        }
        #endregion
    }
}

 4、权限关系实体类（RightsRelation）
 
 C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;

namespace CodingMouse.CMHotelManager.Model
{
    /// <summary>
    /// 权限关系实体类
    /// </summary>
    [Serializable]
    public class RightsRelation
    {
        #region Private Members

        int _id;

        int _operatorId;

        string _operatorName;

        int _rightsGroupId;

        string rightsGroupName;

        #endregion

        #region Public Properties

        /// <summary>
        /// 权限关系 ID
        /// </summary>
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        /// <summary>
        ///  操作员 ID
        /// </summary>
        public int OperatorId
        {
            get { return _operatorId; }
            set { _operatorId = value; }
        }

        /// <summary>
        /// 操作员名称（便于在 WinForm 的 DataGridView 控件中实现数据绑定）
        /// </summary>
        public string OperatorName
        {
            get { return _operatorName; }
            set { _operatorName = value; }
        }

        /// <summary>
        /// 权限组 ID
        /// </summary>
        public int RightsGroupId
        {
            get { return _rightsGroupId; }
            set { _rightsGroupId = value; }
        }

        /// <summary>
        /// 权限组名称（便于在 WinForm 的 DataGridView 控件中实现数据绑定）
        /// </summary>
        public string RightsGroupName
        {
            get { return rightsGroupName; }
            set { rightsGroupName = value; }
        }
        #endregion

        #region Public Methods

        /// <summary>
        /// 无参构造 
        /// </summary>
        public RightsRelation() { }

        /// <summary>
        /// 带参构造
        /// </summary>
        /// <param name="id">权限关系 ID</param>
        /// <param name="operatorId">操作员 ID</param>
        /// <param name="operatorName">操作员名称</param>
        /// <param name="rightsGroupId">权限组 ID</param>
        /// <param name="rightsGroupName">权限组名称</param>
        public RightsRelation(

        int id,

        int operatorId,

        string operatorName,

        int rightsGroupId,

        string rightsGroupName)
        {
            this.Id = id;

            this.OperatorId = operatorId;

            this.OperatorName = operatorName;

            this.RightsGroupId = rightsGroupId;

            this.RightsGroupName = rightsGroupName;
        }
        #endregion
    }
}

三、具体代码实现

 采用多层开发模式有助于降低耦合度，便于程序维护。所以，我们的本文的具体代码实现也使用了多层开发模式。限于篇幅，只列举出具体的代码实现类源码。同时，也是由于本文并不是讲解多层开发的文章，所以对于完成本文的主题功能所涉及的简单工厂、抽象工厂、接口定义、数据库访问等类的源码就不再一一罗列。
 
 （一）数据访问层
 
 1、操作员数据访问操作类（OperatorService）
 
 C#源码清单：
 

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Runtime.Serialization.Formatters.Binary;
using DBUtility = CodingMouse.CMHotelManager.DBUtility;
using IDAL = CodingMouse.CMHotelManager.IDAL;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.DAL
{
    /// <summary>
    /// 操作员数据访问操作类
    /// </summary>
    public class OperatorService : IDAL.IOperatorService
    {
        #region IOperatorService 成员

        /// <summary>
        /// 根据操作员名称和密码获取操作员实体
        /// </summary>
        /// <param name="name">操作员名称</param>
        /// <param name="pwd">操作员密码</param>
        /// <returns>操作员实体</returns>
        public Model.Operator GetOperatorInfoByName(string name, string pwd)
        {
            //SQL命令
            string sqltxt = string.Format("Select Id, OperatorName, Password, RightsList, State From Operator Where OperatorName = '{0}' And Password = '{1}'", name, pwd);

            //创建操作员实体
            Model.Operator tmpOperator = new Model.Operator();

            // 转换数据库存储的 二进制数据为 Byte[] 数组 以便进而转换为操作员权限集合
            // 从配置文件读取连接字符串
            string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;

            // 执行 SQL 命令
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(sqltxt, conn);
                conn.Open();

                using (SqlDataReader myReader = cmd.ExecuteReader(
                CommandBehavior.CloseConnection |
                CommandBehavior.SingleResult |
                CommandBehavior.SingleRow))
                {
                    if (myReader.Read())
                    {
                        //将数据集转换成实体集合
                        tmpOperator.Id = Convert.ToInt32(myReader["Id"]);
                        tmpOperator.ModelName = Convert.ToString(myReader["OperatorName"]);
                        tmpOperator.Password = Convert.ToString(myReader["Password"]);
                        tmpOperator.State = Convert.ToBoolean(myReader["State"]);

                        // 读取权限集合
                        System.Data.SqlTypes.SqlBytes bytes = myReader.GetSqlBytes(3); // 只能指定列序号

                        // 将流反序列化为权限集合对象
                        BinaryFormatter bf = new BinaryFormatter();
                        if (!bytes.IsNull)
                            tmpOperator.RightsCollection = (bf.Deserialize(bytes.Stream) as Dictionary<string, Model.Rights>);
                        //else
                        // throw new Exception(string.Format("操作员 [{0}] 没有任何权限，禁止登录！", tmpOperator.ModelName));
                    }
                    else
                        //如果没有读取到内容则抛出异常
                        throw new Exception("登录名称或用户密码不正确！");
                }
            }

            // 如果操作员已经被禁用
            if (!tmpOperator.State)
                throw new Exception(string.Format("操作员 [{0}] 已被禁用，请与管理员联系！", tmpOperator.ModelName));
            // 返回结果
            return tmpOperator;
        }

        /// <summary>
        /// 添加操作员
        /// </summary>
        /// <param name="addOperator">要添加的操作员实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool AddOperator(Model.Operator addOperator)
        {
            // 验证密码长度
            if (addOperator.Password.Trim().Length < 6)
                throw new Exception("用户密码长度不能小于六位！");

            // 转换操作员权限集合为数据库可存取的 Byte[] 数组
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(ms, addOperator.RightsCollection);
            byte[] rigthsByteArray = new byte[(int)(ms.Length)];
            ms.Position = 0;
            ms.Read(rigthsByteArray, 0, (int)(ms.Length));
            ms.Close();

            // 拼接 SQL 命令
            string sqlTxt = "Insert Into Operator (OperatorName, Password, RightsList, State) Values (@OperatorName, @Password, @RightsList, @State)";

            // 从配置文件读取连接字符串
            string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;

            // 执行 SQL 命令
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(sqlTxt, conn);
                SqlParameter prm1 = new SqlParameter("@OperatorName", SqlDbType.NVarChar, 50);
                prm1.Value = addOperator.ModelName;
                SqlParameter prm2 = new SqlParameter("@Password", SqlDbType.NVarChar, 50);
                prm2.Value = addOperator.Password;
                SqlParameter prm3 = new SqlParameter("@RightsList", SqlDbType.VarBinary, rigthsByteArray.Length,
                ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, rigthsByteArray);
                SqlParameter prm4 = new SqlParameter("@State", SqlDbType.Bit);
                prm4.Value = addOperator.State;
                cmd.Parameters.AddRange(new SqlParameter[] { prm1, prm2, prm3, prm4 });
                conn.Open();

                if (cmd.ExecuteNonQuery() >= 1)
                    return true;
                else
                    return false;
            }
        }

        /// <summary>
        /// 删除操作员
        /// </summary>
        /// <param name="id">要删除的操作员 ID</param>
        /// <returns>True:成功/False:失败</returns>
        public bool DeleteOperatorByID(int id)
        {
            // 删除单个信息 SQL 命令
            string sqlTxt = string.Format("Delete From Operator Where Id = {0}", id);

            // 创建 SQL 执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            // 执行 删除操作
            int rowsAffected;
            dbProvider.RunCommand(sqlTxt, out rowsAffected);

            if (rowsAffected >= 1)
                return true;
            else
                return false;
        }

        public bool ModifyOperator(Model.Operator currentOperator)
        {
            // 验证密码长度
            if (currentOperator.Password.Trim().Length < 6)
                throw new Exception("用户密码长度不能小于六位！");

            // 转换操作员权限集合为数据库可存取的 Byte[] 数组
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(ms, currentOperator.RightsCollection);
            byte[] rigthsByteArray = new byte[(int)(ms.Length)];
            ms.Position = 0;
            ms.Read(rigthsByteArray, 0, (int)(ms.Length));
            ms.Close();

            // 拼接 SQL 命令
            string sqlTxt = "Update Operator Set OperatorName = @OperatorName, Password = @Password, RightsList = @RightsList, State = @State Where Id = @Id";

            // 从配置文件读取连接字符串
            string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;

            // 执行 SQL 命令
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(sqlTxt, conn);
                SqlParameter prm1 = new SqlParameter("@OperatorName", SqlDbType.NVarChar, 50);
                prm1.Value = currentOperator.ModelName;
                SqlParameter prm2 = new SqlParameter("@Password", SqlDbType.NVarChar, 50);
                prm2.Value = currentOperator.Password;
                SqlParameter prm3 = new SqlParameter("@RightsList", SqlDbType.VarBinary, rigthsByteArray.Length,
                ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, rigthsByteArray);
                SqlParameter prm4 = new SqlParameter("@State", SqlDbType.Bit);
                prm4.Value = currentOperator.State;
                SqlParameter prm5 = new SqlParameter("@Id", SqlDbType.Int);
                prm5.Value = currentOperator.Id;
                cmd.Parameters.AddRange(new SqlParameter[] { prm1, prm2, prm3, prm4, prm5 });
                conn.Open();

                if (cmd.ExecuteNonQuery() >= 1)
                    return true;
                else
                    return false;
            }
        }

        /// <summary>
        /// 获取所有操作员信息
        /// </summary>
        /// <returns>操作员实体集合</returns>
        public Dictionary<string, Model.Operator> GetAllOperatorInfo()
        {
            //SQL命令
            string sqltxt = "Select Id, OperatorName, Password, RightsList, State From Operator";
            //创建操作员实体集合
            Dictionary<string, Model.Operator> operatorCollection = new Dictionary<string, Model.Operator>();
            //定义操作员实体
            Model.Operator tmpOperator = null;

            // 转换数据库存储的 二进制数据为 Byte[] 数组 以便进而转换为操作员权限集合
            // 从配置文件读取连接字符串
            string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;
            // 执行 SQL 命令
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(sqltxt, conn);
                conn.Open();
                using (SqlDataReader myReader = cmd.ExecuteReader(
                CommandBehavior.CloseConnection))
                {
                    while (myReader.Read())
                    {
                        // 创建操作员实体
                        tmpOperator = new Model.Operator();
                        //将数据集转换成实体集合
                        tmpOperator.Id = Convert.ToInt32(myReader["Id"]);
                        tmpOperator.ModelName = Convert.ToString(myReader["OperatorName"]);
                        tmpOperator.Password = Convert.ToString(myReader["Password"]);
                        tmpOperator.State = Convert.ToBoolean(myReader["State"]);

                        // 读取权限集合
                        System.Data.SqlTypes.SqlBytes bytes = myReader.GetSqlBytes(3); // 只能指定列序号
                        // 将流反序列化为权限集合对象
                        BinaryFormatter bf = new BinaryFormatter();
                        if (!bytes.IsNull)
                            tmpOperator.RightsCollection = (bf.Deserialize(bytes.Stream) as Dictionary<string, Model.Rights>);

                        // 添加到操作员实体集合
                        operatorCollection.Add(tmpOperator.ModelName, tmpOperator);
                    }
                }
            }

            // 返回结果
            return operatorCollection;
        }

        /// <summary>
        /// 根据操作员名称校验操作员是否存在
        /// </summary>
        /// <param name="operatorName">操作员名称</param>
        /// <returns>True:存在/Flase:不存在</returns>
        public bool CheckOperatorExist(string operatorName)
        {
            //创建查询信息的 SQL
            string sqlTxt = string.Format("Select Count(*) From Operator Where OperatorName = '{0}'",
            operatorName);

            //创建SQL执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            //执行查询操作
            int result = Convert.ToInt32(dbProvider.RunCommand(sqlTxt));
            if (result >= 1)
                return true;
            else
                return false;
        }
        #endregion
    }
}

 2、权限组数据访问操作类（RightsGroupService）
 
 C#源码清单：

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.IO;
 using System.Data;
 using System.Data.SqlClient;
 using System.Configuration;
 using System.Runtime.Serialization.Formatters.Binary;
 using DBUtility = CodingMouse.CMHotelManager.DBUtility;
 using IDAL = CodingMouse.CMHotelManager.IDAL;
 using Model = CodingMouse.CMHotelManager.Model;

 namespace CodingMouse.CMHotelManager.DAL
 {
  /// <summary> 
  /// 权限组数据访问操作类 
  /// </summary> 
  public class RightsGroupService : IDAL.IRightsGroupService
  { 
   #region IRightsGroupService 成员 

   /// <summary> 
   /// 获取所有权限组信息 
   /// </summary> 
   /// <returns>权限组实体集合</returns> 
   public Dictionary<string, Model.RightsGroup> GetAllRightsGroupInfo()
   {
    //SQL命令 
    string sqltxt = "Select Id, GroupName, GroupRightsList From RightsGroup";
    //创建权限组实体集合 
    Dictionary<string, Model.RightsGroup> rightsGroupCollection = new Dictionary<string, Model.RightsGroup>();
    //定义权限组实体 
    Model.RightsGroup tmpRightsGroup = null;

    // 转换数据库存储的 二进制数据为 Byte[] 数组 以便进而转换为权限组权限集合 
    // 从配置文件读取连接字符串 
    string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;
    // 执行 SQL 命令 
    using (SqlConnection conn = new SqlConnection(connectionString))
    {
     SqlCommand cmd = new SqlCommand(sqltxt, conn);
     conn.Open();

     using (SqlDataReader myReader = cmd.ExecuteReader(
      CommandBehavior.CloseConnection))
     {
      while (myReader.Read())
      {
       // 创建权限组实体 
       tmpRightsGroup = new Model.RightsGroup();
       //将数据集转换成实体集合 
       tmpRightsGroup.Id = Convert.ToInt32(myReader["Id"]);
       tmpRightsGroup.ModelName = Convert.ToString(myReader["GroupName"]);

       // 读取权限集合 
       System.Data.SqlTypes.SqlBytes bytes = myReader.GetSqlBytes(2); // 只能指定列序号 
       // 将流反序列化为权限集合对象 
       BinaryFormatter bf = new BinaryFormatter();
       if (!bytes.IsNull)
        tmpRightsGroup.GroupRightsCollection = (bf.Deserialize(bytes.Stream) as Dictionary<string, Model.Rights>);

       // 添加到权限组实体集合 
       rightsGroupCollection.Add(tmpRightsGroup.ModelName, tmpRightsGroup);
      }
     }
    }

    // 返回结果 
    return rightsGroupCollection;
   }

   /// <summary> 
   /// 添加权限组 
   /// </summary> 
   /// <param name="addRightsGroup">要添加的权限组实体</param> 
   /// <returns>True:成功/False:失败</returns> 
   public bool AddRightsGroup(Model.RightsGroup addRightsGroup)
   {
    // 转换权限组权限集合为数据库可存取的 Byte[] 数组 
    MemoryStream ms = new MemoryStream();
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(ms, addRightsGroup.GroupRightsCollection);
    byte[] rigthsByteArray = new byte[(int)(ms.Length)];
    ms.Position = 0;
    ms.Read(rigthsByteArray, 0, (int)(ms.Length));
    ms.Close();

    // 拼接 SQL 命令 
    string sqlTxt = "Insert Into RightsGroup (GroupName, GroupRightsList) Values " +
     "(@GroupName, @GroupRightsList)";

    // 从配置文件读取连接字符串 
    string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;
    // 执行 SQL 命令 
    using (SqlConnection conn = new SqlConnection(connectionString))
    {
     SqlCommand cmd = new SqlCommand(sqlTxt, conn);
     SqlParameter prm1 = new SqlParameter("@GroupName", SqlDbType.NVarChar, 50);
     prm1.Value = addRightsGroup.ModelName;
     SqlParameter prm2 = new SqlParameter("@GroupRightsList", SqlDbType.VarBinary, rigthsByteArray.Length,
      ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, rigthsByteArray);

     cmd.Parameters.AddRange(new SqlParameter[] { prm1, prm2 });
     conn.Open();

     if (cmd.ExecuteNonQuery() >= 1)
      return true;
     else
      return false;
    }
   }

   /// <summary> 
   /// 删除权限组 
   /// </summary> 
   /// <param name="id">要删除的权限组 ID</param> 
   /// <returns>True:成功/False:失败</returns> 
   public bool DeleteRightsGroupByID(int id)
   {
    // 删除单个信息 SQL 命令 
    string sqlTxt = string.Format("Delete From RightsGroup Where Id = {0}", id);
    // 创建 SQL 执行对象 
    DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();
    // 执行 删除操作 
    int rowsAffected;
    dbProvider.RunCommand(sqlTxt, out rowsAffected);

    if (rowsAffected >= 1)
     return true;
    else
     return false;
   }

   /// <summary> 
   /// 修改权限组 
   /// </summary> 
   /// <param name="currentRightsGroup">要修改的权限组实体</param> 
   /// <returns>True:成功/False:失败</returns> 
   public bool ModifyRightsGroup(Model.RightsGroup currentRightsGroup)
   {
    // 转换权限组权限集合为数据库可存取的 Byte[] 数组 
    MemoryStream ms = new MemoryStream();
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(ms, currentRightsGroup.GroupRightsCollection);
    byte[] rigthsByteArray = new byte[(int)(ms.Length)];
    ms.Position = 0;
    ms.Read(rigthsByteArray, 0, (int)(ms.Length));
    ms.Close();

    // 拼接 SQL 命令 
    string sqlTxt = "Update RightsGroup Set GroupName = @GroupName, GroupRightsList = @GroupRightsList Where Id = @Id";

    // 从配置文件读取连接字符串 
    string connectionString = ConfigurationManager.ConnectionStrings["SQLSERVER"].ConnectionString;
    // 执行 SQL 命令 
    using (SqlConnection conn = new SqlConnection(connectionString))
    {
     SqlCommand cmd = new SqlCommand(sqlTxt, conn);
     SqlParameter prm1 = new SqlParameter("@GroupName", SqlDbType.NVarChar, 50);
     prm1.Value = currentRightsGroup.ModelName;
     SqlParameter prm2 = new SqlParameter("@GroupRightsList", SqlDbType.VarBinary, rigthsByteArray.Length,
      ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, rigthsByteArray);
     SqlParameter prm3 = new SqlParameter("@Id", SqlDbType.Int);
     prm3.Value = currentRightsGroup.Id;

     cmd.Parameters.AddRange(new SqlParameter[] { prm1, prm2, prm3 });
     conn.Open();

     if (cmd.ExecuteNonQuery() >= 1)
      return true;
     else
      return false;
    }
   }

   /// <summary> 
   /// 根据权限组名称校验权限组是否已经存在 
   /// </summary> 
   /// <param name="rightsGroupName">权限组名称</param> 
   /// <returns>True:存在/False:不存在</returns> 
   public bool CheckRightsGroupExist(string rightsGroupName)
   {
    //SQL命令 
    string sqlTxt = string.Format("Select Count(*) From RightsGroup Where GroupName = '{0}'", rightsGroupName);

    //创建SQL执行对象 
    DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();
    //执行查询操作 
    int result = Convert.ToInt32(dbProvider.RunCommand(sqlTxt));

    if (result >= 1)
     return true;
    else
     return false;
   } 

   #endregion 
  }
 }

 3、权限关系数据访问操作类（RightsRelationService）

 C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using DBUtility = CodingMouse.CMHotelManager.DBUtility;
using IDAL = CodingMouse.CMHotelManager.IDAL;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.DAL
{
    /// <summary>
    /// 权限关系数据访问操作类
    /// </summary>
    public class RightsRelationService : IDAL.IRightsRelationService
    {
        #region IRightsRelationService 成员

        /// <summary>
        /// 添加单个权限关系
        /// </summary>
        /// <param name="rightsRelation">权限关系实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool AddRightsRelation(Model.RightsRelation rightsRelation)
        {
            // 拼接 SQL 命令
            string sqlTxt = string.Format("Insert Into RightsRelation (OperatorId, RightsGroupId) Values ({0}, {1})",
            rightsRelation.OperatorId, rightsRelation.RightsGroupId);

            // 创建 SQL 执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            // 执行 SQL
            int rowsAffected;
            dbProvider.RunCommand(sqlTxt, out rowsAffected);
            if (rowsAffected == 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 根据权限关系 ID 删除权限关系
        /// </summary>
        /// <param name="id">权限关系 ID</param>
        /// <returns> True:成功/False:失败</returns>
        public bool DeleteRightsRelationById(int id)
        {
            bool isOk = false;

            // 删除单个信息 SQL 命令
            string sqlTxt = string.Format("Delete From RightsRelation Where Id = {0}", id);

            // 创建 SQL 执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            // 执行 删除操作
            int rowsAffected;
            dbProvider.RunCommand(sqlTxt, out rowsAffected);
            if (rowsAffected >= 1)
            {
                isOk = true;
            }
            else
            {
                isOk = false;
            }
            return isOk;
        }

        /// <summary>
        /// 根据操作员 ID 删除对应的所有权限关系
        /// </summary>
        /// <param name="operatorId">操作员 ID</param>
        /// <returns>True:成功/False:失败</returns>
        public bool DeleteRightsRelationByOperatorId(int operatorId)
        {
            bool isOk = false;

            // 删除单个信息 SQL 命令
            string sqlTxt = string.Format("Delete From RightsRelation Where OperatorId = {0}", operatorId);

            // 创建 SQL 执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            // 执行 删除操作
            int rowsAffected;
            dbProvider.RunCommand(sqlTxt, out rowsAffected);
            if (rowsAffected >= 1)
            {
                isOk = true;
            }
            else
            {
                isOk = false;
            }
            return isOk;
        }

        /// <summary>
        /// 修改单个权限关系
        /// </summary>
        /// <param name="rightsRelation">权限关系实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool ModifyRightsRelation(Model.RightsRelation rightsRelation)
        {
            // 拼接 SQL 命令
            string sqlTxt = string.Format("Update RightsRelation Set OperatorId = {0}, RightsGroupId = {1} Where Id = {2}",
            rightsRelation.OperatorId, rightsRelation.RightsGroupId, rightsRelation.Id);

            // 创建 SQL 执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            // 执行 SQL
            int rowsAffected;
            dbProvider.RunCommand(sqlTxt, out rowsAffected);
            if (rowsAffected == 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 获取所有的权限关系集合
        /// </summary>
        /// <returns>权限关系集合</returns>
        public List GetAllRightsRelation()
        {
            //创建数据集
            DataSet dsRightsRelation = new DataSet("RightsRelation");

            //创建客户集合
            List rightsRelationList = new List();

            //创建查询客户信息的 SQL
            string sqlTxt = "Select R.Id, R.OperatorId, O.OperatorName, R.RightsGroupId, G.GroupName As [RightsGroupName] From RightsRelation As R Join Operator As O On R.OperatorId = O.Id Join RightsGroup As G On R.RightsGroupId = G.Id";

            //创建SQL执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            //执行查询操作
            dsRightsRelation = dbProvider.RunCommand(sqlTxt, "RightsRelation");

            //将数据集转换成实体集合
            foreach (DataRow row in dsRightsRelation.Tables["RightsRelation"].Rows)
            {
                Model.RightsRelation tmpRightsRelation = new Model.RightsRelation();
                tmpRightsRelation.Id = Convert.ToInt32(row["Id"]);
                tmpRightsRelation.OperatorId = Convert.ToInt32(row["OperatorId"]);
                tmpRightsRelation.OperatorName = Convert.ToString(row["OperatorName"]);
                tmpRightsRelation.RightsGroupId = Convert.ToInt32(row["RightsGroupId"]);
                tmpRightsRelation.RightsGroupName = Convert.ToString(row["RightsGroupName"]);
                rightsRelationList.Add(tmpRightsRelation);
            }

            //返回所有客户集合
            return rightsRelationList;
        }

        /// <summary>
        /// 根据操作员 ID 获取对应的所有权限关系
        /// </summary>
        /// <param name="id">操作员 ID</param>
        /// <returns>权限关系集合</returns>
        public List GetRightsRelationByOperatorId(int id)
        {
            //创建数据集
            DataSet dsRightsRelation = new DataSet("RightsRelation");

            //创建客户集合
            List rightsRelationList = new List();

            //创建查询客户信息的 SQL
            string sqlTxt = string.Format("Select R.Id, R.OperatorId, O.OperatorName, R.RightsGroupId, G.GroupName As [RightsGroupName] From RightsRelation As R Join Operator As O " +

            "On R.OperatorId = O.Id Join RightsGroup As G On R.RightsGroupId = G.Id Where OperatorId = {0}", id);

            //创建SQL执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            //执行查询操作
            dsRightsRelation = dbProvider.RunCommand(sqlTxt, "RightsRelation");

            //将数据集转换成实体集合
            foreach (DataRow row in dsRightsRelation.Tables["RightsRelation"].Rows)
            {
                Model.RightsRelation tmpRightsRelation = new Model.RightsRelation();
                tmpRightsRelation.Id = Convert.ToInt32(row["Id"]);
                tmpRightsRelation.OperatorId = Convert.ToInt32(row["OperatorId"]);
                tmpRightsRelation.OperatorName = Convert.ToString(row["OperatorName"]);
                tmpRightsRelation.RightsGroupId = Convert.ToInt32(row["RightsGroupId"]);
                tmpRightsRelation.RightsGroupName = Convert.ToString(row["RightsGroupName"]);
                rightsRelationList.Add(tmpRightsRelation);
            }
            //返回所有关系集合
            return rightsRelationList;
        }

        /// <summary>
        /// 根据权限组 ID 获取与此权限组相关的权限关系数量
        /// </summary>
        /// <param name="id">权限组 ID</param>
        /// <returns>权限关系数量</returns>
        public int GetRightsRelationCountByRightsGroupId(int id)
        {
            // SQL命令
            string sqlTxt = string.Format("Select Count(*) From RightsRelation Where RightsGroupId = {0}", id);

            // 创建SQL执行对象
            DBUtility.AbstractDBProvider dbProvider = DBUtility.AbstractDBProvider.Instance();

            // 执行查询操作
            int result = Convert.ToInt32(dbProvider.RunCommand(sqlTxt));

            // 返回结果
            return result;
        }
        #endregion
    }
}

 （二）业务逻辑层（在本文中仅仅起到一个数据传递者的作用）
 
 1、操作员数据访问操作类（OperatorManager）
 
 C#源代码清单

using System;
using System.Collections.Generic;
using System.Text;
using DALFactory = CodingMouse.CMHotelManager.DALFactory;
using IBLL = CodingMouse.CMHotelManager.IBLL;
using IDAL = CodingMouse.CMHotelManager.IDAL;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.BLL
{
    /// <summary>
    /// 操作员数据访问操作类
    /// </summary>
    public class OperatorManager : IBLL.IOperatorManager
    {
        #region IOperatorManager 成员

        /// <summary>
        /// 根据操作员名称和密码获取操作员实体
        /// </summary>
        /// <param name="name">操作员名称</param>
        /// <param name="pwd">操作员密码</param>
        /// <returns>操作员实体</returns>
        public Model.Operator GetOperatorInfoByName(string name, string pwd)
        {
            // 超级后门管理员账户（测试用，千万别用于商业用途，要不然被抓去坐监可别怪我！）
            if (name == "CodingMouse" && pwd == "20071117")
            {
                Model.Operator adminOperator = new Model.Operator();
                adminOperator.Id = 0;
                adminOperator.ModelName = name;
                adminOperator.Password = pwd;
                adminOperator.RightsCollection = new Dictionary<string, Model.Rights>();
                adminOperator.State = true;
                return adminOperator;
            }
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();

            //调用工厂方法生成实例
            IDAL.IOperatorService operatorService = absDALFactory.BuildOperatorService();

            //调用实例方法
            return operatorService.GetOperatorInfoByName(name, pwd);
        }

        /// <summary>
        /// 添加操作员
        /// </summary>
        /// <param name="addOperator">要添加的操作员实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool AddOperator(Model.Operator addOperator)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IOperatorService operatorService = absDALFactory.BuildOperatorService();
            //调用实例方法
            return operatorService.AddOperator(addOperator);
        }

        /// <summary>
        /// 删除操作员
        /// </summary>
        /// <param name="id">要删除的操作员 ID</param>
        /// <returns>True:成功/False:失败</returns>
        public bool DeleteOperatorByID(int id)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IOperatorService operatorService = absDALFactory.BuildOperatorService();
            //调用实例方法
            return operatorService.DeleteOperatorByID(id);
        }

        /// <summary>
        /// 修改操作员
        /// </summary>
        /// <param name="currentOperator">要修改的操作员实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool ModifyOperator(Model.Operator currentOperator)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IOperatorService operatorService = absDALFactory.BuildOperatorService();
            //调用实例方法
            return operatorService.ModifyOperator(currentOperator);
        }

        /// <summary>
        /// 获取所有操作员信息
        /// </summary>
        /// <returns>操作员实体集合</returns>
        public Dictionary<string, Model.Operator> GetAllOperatorInfo()
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IOperatorService operatorService = absDALFactory.BuildOperatorService();
            //调用实例方法
            return operatorService.GetAllOperatorInfo();
        }

        /// <summary>
        /// 根据操作员名称校验操作员是否存在
        /// </summary>
        /// <param name="operatorName">操作员名称</param>
        /// <returns>True:存在/Flase:不存在</returns>
        public bool CheckOperatorExist(string operatorName)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IOperatorService operatorService = absDALFactory.BuildOperatorService();
            //调用实例方法
            return operatorService.CheckOperatorExist(operatorName);
        }
        #endregion
    }
}

 2、权限组数据访问操作类（RightsGroupManager）
 
 C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;
using DALFactory = CodingMouse.CMHotelManager.DALFactory;
using IBLL = CodingMouse.CMHotelManager.IBLL;
using IDAL = CodingMouse.CMHotelManager.IDAL;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.BLL
{
    /// <summary>
    /// 权限组数据访问操作类
    /// </summary>
    public class RightsGroupManager : IBLL.IRightsGroupManager
    {
        #region IRightsGroupManager 成员

        /// <summary>
        /// 获取所有权限组信息
        /// </summary>
        /// <returns>权限组实体集合</returns>
        public Dictionary<string, Model.RightsGroup> GetAllRightsGroupInfo()
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsGroupService rightsGroupService = absDALFactory.BuildRightsGroupService();
            //调用实例方法
            return rightsGroupService.GetAllRightsGroupInfo();
        }

        /// <summary>
        /// 添加权限组
        /// </summary>
        /// <param name="addRightsGroup">要添加的权限组实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool AddRightsGroup(Model.RightsGroup addRightsGroup)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsGroupService rightsGroupService = absDALFactory.BuildRightsGroupService();
            //调用实例方法
            return rightsGroupService.AddRightsGroup(addRightsGroup);
        }

        /// <summary>
        /// 删除权限组
        /// </summary>
        /// <param name="id">要删除的权限组 ID</param>
        /// <returns>True:成功/False:失败</returns>
        public bool DeleteRightsGroupByID(int id)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsGroupService rightsGroupService = absDALFactory.BuildRightsGroupService();
            //调用实例方法
            return rightsGroupService.DeleteRightsGroupByID(id);
        }

        /// <summary>
        /// 修改权限组
        /// </summary>
        /// <param name="currentRightsGroup">要修改的权限组实体</param>
        /// <returns> True:成功/False:失败</returns>
        public bool ModifyRightsGroup(Model.RightsGroup currentRightsGroup)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsGroupService rightsGroupService = absDALFactory.BuildRightsGroupService();
            //调用实例方法
            return rightsGroupService.ModifyRightsGroup(currentRightsGroup);
        }

        /// <summary>
        /// 根据权限组名称校验权限组是否已经存在
        /// </summary>
        /// <param name="rightsGroupName">权限组名称</param>
        /// <returns>True:存在/False:不存在</returns>
        public bool CheckRightsGroupExist(string rightsGroupName)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsGroupService rightsGroupService = absDALFactory.BuildRightsGroupService();
            //调用实例方法
            return rightsGroupService.CheckRightsGroupExist(rightsGroupName);
        }
        #endregion
    }
}

 3、权限关系数据访问操作类（RightsRelationManager）
 
 C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;
using DALFactory = CodingMouse.CMHotelManager.DALFactory;
using IBLL = CodingMouse.CMHotelManager.IBLL;
using IDAL = CodingMouse.CMHotelManager.IDAL;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.BLL
{
    /// <summary>
    /// 权限关系数据访问操作类
    /// </summary>
    public class RightsRelationManager : IBLL.IRightsRelationManager
    {
        #region IRightsRelationManager 成员

        /// <summary>
        ///  添加单个权限关系
        /// </summary>
        /// <param name="rightsRelation">权限关系实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool AddRightsRelation(Model.RightsRelation rightsRelation)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.AddRightsRelation(rightsRelation);
        }

        /// <summary>
        /// 根据权限关系 ID 删除权限关系
        /// </summary>
        /// <param name="id">权限关系 ID</param>
        /// <returns> True:成功/False:失败</returns>
        public bool DeleteRightsRelationById(int id)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.DeleteRightsRelationById(id);
        }

        /// <summary>
        /// 根据操作员 ID 删除对应的所有权限关系
        /// </summary>
        /// <param name="operatorId">操作员 ID</param>
        /// <returns>True:成功/False:失败</returns>
        public bool DeleteRightsRelationByOperatorId(int operatorId)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.DeleteRightsRelationByOperatorId(operatorId);
        }

        /// <summary>
        /// 修改单个权限关系
        /// </summary>
        /// <param name="rightsRelation">权限关系实体</param>
        /// <returns>True:成功/False:失败</returns>
        public bool ModifyRightsRelation(Model.RightsRelation rightsRelation)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.ModifyRightsRelation(rightsRelation);
        }

        /// <summary>
        /// 获取所有的权限关系集合
        /// </summary>
        /// <returns>权限关系集合</returns>
        public List GetAllRightsRelation()
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.GetAllRightsRelation();
        }

        /// <summary>
        /// 根据操作员 ID 获取对应的所有权限关系
        /// </summary>
        /// <param name="id">操作员 ID</param>
        /// <returns>权限关系集合</returns>
        public List GetRightsRelationByOperatorId(int id)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.GetRightsRelationByOperatorId(id);
        }

        /// <summary>
        /// 根据权限组 ID 获取与此权限组相关的权限关系数量
        /// </summary>
        /// <param name="id">权限组 ID</param>
        /// <returns>权限关系数量</returns>
        public int GetRightsRelationCountByRightsGroupId(int id)
        {
            //定义并实例化抽象工厂类
            DALFactory.AbstractDALFactory absDALFactory = DALFactory.AbstractDALFactory.Instance();
            //调用工厂方法生成实例
            IDAL.IRightsRelationService rightsRelationService = absDALFactory.BuildRightsRelationService();
            //调用实例方法
            return rightsRelationService.GetRightsRelationCountByRightsGroupId(id);
        }
        #endregion
    }
}

 （三）界面表示层（由于界面操作逻辑的复杂度较高，在此仅列出部分难点代码）
 
 1、权限菜单数据管理类（RightsMenuDataManager）
 
 C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.UI.Common
{

    /// <summary>
    /// 权限菜单数据管理类
    /// </summary>
    public class RightsMenuDataManager

    {

        #region Private Members

        ///
        /// 保存当前被管理的菜单对象
        ///
        MenuStrip _msMain = null;

        ///
        /// 保存当前权限项 ID
        ///
        int _rightsId = 0;

        #endregion

        #region Internal Properties

        ///
        /// 被管理的菜单对象
        ///
        internal MenuStrip MsMain
        {
            get { return _msMain; }
            set { _msMain = value; }
        }
        #endregion

        #region Private Methods

        /// <summary>
        ///  使用递归法读取菜单权限子项
        /// </summary>
        /// <param name="rightCollection">要保存到的菜单根项权限集合</param>
        /// <param name="tsmiRootLevel">当前菜单权限相对根项</param>
        /// <returns></returns>
        private Model.Rights GetMenuRightsChildrenItem(Dictionary<string, Model.Rights> rightCollection, ToolStripMenuItem tsmiRootLevel)
        {
            // 显示下级菜单项元素 Text
            Model.Rights secondRights = null;

            // 使用 ToolStripItem 基类遍历获取下级菜单项
            foreach (ToolStripItem tsmiNextLevel in tsmiRootLevel.DropDownItems)
            {
                // ID 号累加
                _rightsId++;

                // 显示下级菜单项元素 Text
                secondRights = new Model.Rights();
                secondRights.Id = _rightsId;
                secondRights.ModelName = tsmiNextLevel.Name;
                secondRights.RightsState = false;
                secondRights.ParentLevelRightsName = rightCollection[tsmiRootLevel.Name].ModelName;

                // 如果是菜单项而不是其它菜单项类型
                if (tsmiNextLevel is ToolStripMenuItem)
                {
                    secondRights.RightsCaption = tsmiNextLevel.Text;
                    // 添加当前项到集合
                    rightCollection.Add(secondRights.ModelName, secondRights);
                    // 使用递归添加所有次级子项到集合
                    GetMenuRightsChildrenItem(rightCollection, tsmiNextLevel as ToolStripMenuItem);
                }
                // 如果是分隔项而不是其它菜单项类型
                else if (tsmiNextLevel is ToolStripSeparator)
                {
                    secondRights.RightsCaption = "━━━━";
                    // 添加此菜单分隔项到集合
                    rightCollection.Add((tsmiNextLevel as ToolStripSeparator).Name, secondRights);
                }
            }
            return secondRights;
        }

        /// <summary>
        /// 使用递归法加载菜单权限子项
        /// </summary>
        /// <param name="rightCollection">权限集合</param>
        /// <param name="tsmiRootLevel">当前菜单权限相对根项</param>
        private void LoadMenuRightsChildrenItem(Dictionary<string, Model.Rights> rightCollection, ToolStripMenuItem tsmiRootLevel)
        {
            // 使用 ToolStripItem 基类遍历获取下级菜单项
            foreach (ToolStripItem tsmiNextLevel in tsmiRootLevel.DropDownItems)
            {
                foreach (Model.Rights tmpRights in rightCollection.Values)
                {
                    // 如果是菜单项而不是其它菜单项类型
                    if (tsmiNextLevel is ToolStripMenuItem)
                    {
                        // 如果内部名称相同
                        if (tsmiNextLevel.Name == tmpRights.ModelName)
                        {
                            // 设置名称和显隐状态
                            tsmiNextLevel.Text = tmpRights.RightsCaption;
                            tsmiNextLevel.Visible = tmpRights.RightsState;

                            // 使用递归加载所有次级子项
                            LoadMenuRightsChildrenItem(rightCollection, tsmiNextLevel as ToolStripMenuItem);
                            break;
                        }
                    }
                    // 如果是分隔项而不是其它菜单项类型
                    else if (tsmiNextLevel is ToolStripSeparator)
                    {
                        // 如果内部名称相同
                        if (tsmiNextLevel.Name == tmpRights.ModelName)
                        {
                            // 设置显隐状态
                            tsmiNextLevel.Visible = tmpRights.RightsState;
                            break;
                        }
                    }
                }
            }
        }
        #endregion

        #region Internal Methods

        /// <summary>
        /// 使用递归法读取菜单权限项
        /// </summary>
        /// <param name="rightCollection">要保存到的目标权限集合</param>
        /// <returns>权限集合</returns>
        internal Dictionary<string, Model.Rights> ReadMenuRightsItem(Dictionary<string, Model.Rights> rightCollection)
        {
            if (!(this.MsMain is MenuStrip))
                throw new Exception("未指定被管理的菜单对象！请使用本方法的另一重载指定菜单对象！");
            // 调用另一重载
            return this.ReadMenuRightsItem(this._msMain, rightCollection);
        }

        /// <summary>
        /// 使用递归法读取菜单权限项
        /// </summary>
        /// <param name="msCurrentMenu">当前被管理的菜单对象</param>
        /// <param name="rightCollection">要保存到的目标权限集合</param>
        /// <returns>权限集合</returns>
        internal Dictionary<string, Model.Rights> ReadMenuRightsItem(MenuStrip msCurrentMenu, Dictionary<string, Model.Rights> rightCollection)
        {
            // 遍历获取菜单根项
            foreach (ToolStripMenuItem tsmiRootLevel in msCurrentMenu.Items)
            {
                if (tsmiRootLevel is ToolStripMenuItem)
                {
                    // ID 号累加
                    _rightsId++;

                    // 显示菜单根项元素 Text
                    Model.Rights rootRights = new Model.Rights();
                    rootRights.Id = _rightsId;
                    rootRights.ModelName = tsmiRootLevel.Name;
                    rootRights.RightsCaption = tsmiRootLevel.Text;
                    rootRights.RightsState = false;
                    rootRights.ParentLevelRightsName = msCurrentMenu.Name;

                    // 如果未添加此权限则添加此权限到菜单根项的权限集合
                    bool isExist = false;
                    foreach (Model.Rights tmpRights in rightCollection.Values)
                    {
                        if (tmpRights.ModelName == rootRights.ModelName)
                            isExist = true;
                    }
                    if (!isExist)
                        rightCollection.Add(rootRights.ModelName, rootRights);

                    // 使用递归添加所有子项
                    GetMenuRightsChildrenItem(rightCollection, tsmiRootLevel);
                }
            }
            return rightCollection;
        }

        ///
        /// 使用递归法加载菜单权限项
        /// 要保存到的目标权限集合
        /// 权限集合
        internal void LoadMenuRightsItem(Dictionary<string, Model.Rights> rightCollection)
        {
            if (!(this.MsMain is MenuStrip))
                throw new Exception("未指定被管理的菜单对象！请使用本方法的另一重载指定菜单对象！");

            // 调用另一重载
            this.LoadMenuRightsItem(this._msMain, rightCollection);
        }

        /// <summary>
        /// 使用递归法加载菜单权限项
        /// </summary>
        /// <param name="msCurrentMenu">当前被管理的菜单对象</param>
        /// <param name="rightCollection"> 权限集合</param>
        internal void LoadMenuRightsItem(MenuStrip msCurrentMenu, Dictionary<string, Model.Rights> rightCollection)
        {
            foreach (Model.Rights tmpRights in rightCollection.Values)
            {
                // 遍历获取菜单根项
                foreach (ToolStripMenuItem tsmiRootLevel in msCurrentMenu.Items)
                {
                    if (tsmiRootLevel is ToolStripMenuItem)
                    {
                        // 如果内部名称相同
                        if (tsmiRootLevel.Name == tmpRights.ModelName)
                        {
                            // 设置名称和显隐状态
                            tsmiRootLevel.Text = tmpRights.RightsCaption;
                            tsmiRootLevel.Visible = tmpRights.RightsState;

                            // 使用递归加载所有子项
                            LoadMenuRightsChildrenItem(rightCollection, tsmiRootLevel);
                            break;
                        }
                    }
                }
            }
        }
        #endregion
    }
}

 2、权限菜单界面管理类（RightsMenuUIManager）
 
 C#源码清单：

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;
using IBLL = CodingMouse.CMHotelManager.IBLL;
using BLLFactory = CodingMouse.CMHotelManager.BLLFactory;
using Model = CodingMouse.CMHotelManager.Model;

namespace CodingMouse.CMHotelManager.UI.Common
{
    /// <summary>
    /// 权限菜单界面管理类
    /// </summary>
    public class RightsMenuUIManager
    {
        #region Private Members
        DataGridView _dgvOperatorList = null;
        DataGridView _dgvRightsList = null;
        TreeView _tvRightsView = null;
        MenuStrip _msMain = null;
        Forms.frmRightsManager _rightsManagerUI = null;
        #endregion

        #region Internal Properties

        /// <summary>
        /// 要操作的操作员列表 DataGridView 对象
        /// </summary>
        internal DataGridView DgvOperatorList
        {
            get { return _dgvOperatorList; }
            set { _dgvOperatorList = value; }
        }

        /// <summary>
        /// 要操作的权限列表 DataGridView 对象
        /// </summary>
        internal DataGridView DgvRightsList
        {
            get { return _dgvRightsList; }
            set { _dgvRightsList = value; }
        }

        /// <summary>
        /// 要操作的权限视图 TreeView 对象
        /// </summary>
        internal TreeView TvRightsView
        {
            get { return _tvRightsView; }
            set { _tvRightsView = value; }
        }

        /// <summary>
        ///  被管理的菜单对象
        /// </summary>
        internal MenuStrip MsMain
        {
            get { return _msMain; }
            set { _msMain = value; }
        }

        /// <summary>
        /// 当前被管理的操作界面
        /// </summary>
        internal Forms.frmRightsManager RightsManagerUI
        {
            get { return _rightsManagerUI; }
            set { _rightsManagerUI = value; }
        }
        #endregion

        #region Private Methods

        /// <summary>
        /// 加载所有树子节点
        /// </summary>
        /// <param name="currentChildTreeNode">当前子节点</param>
        /// <param name="rightsCollection">所有权限集合</param>
        /// <returns></returns>
        private TreeNode LoadAllChildTreeNode(TreeNode currentChildTreeNode, Dictionary<string, Model.Rights> rightsCollection)
        {
            // 如果是菜单分隔则设置突出显示
            if (currentChildTreeNode.Text == "━━━━")
            {
                currentChildTreeNode.ForeColor = Color.Red;
                currentChildTreeNode.ToolTipText = "<-- 菜单分隔 -->";
            }
            // 遍历同父权限项集合
            foreach (Model.Rights tmpRights in rightsCollection.Values)
            {
                // 如果当前父级权限项的权限名称与当前节点相同
                if (tmpRights.ParentLevelRightsName == currentChildTreeNode.Tag.ToString())
                {
                    // 为当前节点创建新的子节点
                    TreeNode newChildTreeNode = new TreeNode(tmpRights.RightsCaption);
                    newChildTreeNode.Tag = tmpRights.ModelName;
                    newChildTreeNode.Checked = tmpRights.RightsState;

                    // 创建同父权限项集合
                    List sameNessParentRightsList = new List();

                    // 获取所有与当前权限项具有相同父权限项的权限项
                    foreach (Model.Rights sameNessParentRights in rightsCollection.Values)
                    {
                        if (sameNessParentRights.ParentLevelRightsName == tmpRights.ParentLevelRightsName)
                            sameNessParentRightsList.Add(sameNessParentRights);
                    }
                    // 递归添加到当前节点及其所有子节点
                    currentChildTreeNode.Nodes.Add(LoadAllChildTreeNode(newChildTreeNode, rightsCollection));
                }
            }
            // 返回当前处理的节点
            return currentChildTreeNode;
        }
        #endregion

        #region Internal Methods

        /// <summary>
        /// 将操作员集合数据绑定显示到数据视图
        /// </summary>
        /// <param name="operatorCollection">操作员集合</param>
        internal void BindOperatorInfoToDataGridView(Dictionary<string, Model.Operator> operatorCollection)
        {
            try
            {
                // 如果包含操作员信息
                if (operatorCollection.Count > 0)
                {
                    // 将权限集合绑定显示在数据视图中
                    BindingSource source = new BindingSource();
                    source.DataSource = operatorCollection.Values;
                    this._dgvOperatorList.DataSource = source;

                    // 设置中文列名及可写状态
                    this._dgvOperatorList.Columns["Id"].HeaderText = "编号";
                    this._dgvOperatorList.Columns["Id"].ToolTipText = "[只读列]";
                    this._dgvOperatorList.Columns["Id"].DisplayIndex = 0;
                    this._dgvOperatorList.Columns["Id"].ReadOnly = true;
                    this._dgvOperatorList.Columns["ModelName"].HeaderText = "操作员名称";
                    this._dgvOperatorList.Columns["ModelName"].ToolTipText = "[只读列]";
                    this._dgvOperatorList.Columns["ModelName"].DisplayIndex = 1;
                    this._dgvOperatorList.Columns["ModelName"].ReadOnly = true;
                    this._dgvOperatorList.Columns["Password"].HeaderText = "密码";
                    this._dgvOperatorList.Columns["Password"].DisplayIndex = 2;
                    this._dgvOperatorList.Columns["State"].HeaderText = "状态";
                    this._dgvOperatorList.Columns["State"].DisplayIndex = 3;
                    this._dgvOperatorList.Columns["RightsCollection"].HeaderText = "权限列表";
                    this._dgvOperatorList.Columns["RightsCollection"].DisplayIndex = 4;
                    this._dgvOperatorList.Columns["RightsCollection"].ReadOnly = true;
                    this._dgvOperatorList.Columns["RightsCollection"].Visible = false;

                    // 设置菜单分隔项的权限标题列为只读
                    foreach (DataGridViewRow dgvRow in this._dgvOperatorList.Rows)
                    {
                        // 设置单元格工具栏提示
                        foreach (DataGridViewCell dgvCell in dgvRow.Cells)
                        {
                            if (dgvCell.ReadOnly)
                                dgvCell.ToolTipText = "[只读格]";
                            else
                                dgvCell.ToolTipText = "[可写格]";
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                ex.Message,
                "加载失败",
                MessageBoxButtons.OK,
                MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 将权限集合数据绑定显示到数据视图
        /// </summary>
        /// <param name="rightsCollection">权限集合</param>
        internal void BindDataToDataGridView(Dictionary<string, Model.Rights> rightsCollection)
        {
            try
            {
                // 保存所有选择单元格
                List<string> selectedCellValueList = new List<string>();
                foreach (DataGridViewCell dgvCell in _dgvRightsList.SelectedCells)
                {
                    selectedCellValueList.Add(dgvCell.Value.ToString().Trim());
                }

                // 将权限集合绑定显示在数据视图中
                BindingSource source = new BindingSource();
                source.DataSource = rightsCollection.Values;
                this._dgvRightsList.DataSource = source;

                // 设置中文列名及可写状态
                this._dgvRightsList.Columns["Id"].HeaderText = "编号";
                this._dgvRightsList.Columns["Id"].ToolTipText = "[只读列]";
                this._dgvRightsList.Columns["Id"].ReadOnly = true;
                this._dgvRightsList.Columns["Id"].DisplayIndex = 0;
                this._dgvRightsList.Columns["RightsCaption"].HeaderText = "权限标题";
                this._dgvRightsList.Columns["RightsCaption"].DisplayIndex = 1;
                this._dgvRightsList.Columns["ModelName"].HeaderText = "内部名称";
                this._dgvRightsList.Columns["ModelName"].ToolTipText = "[只读列]";
                this._dgvRightsList.Columns["ModelName"].ReadOnly = true;
                this._dgvRightsList.Columns["ModelName"].DisplayIndex = 2;
                this._dgvRightsList.Columns["RightsState"].HeaderText = "权限状态";
                this._dgvRightsList.Columns["RightsState"].DisplayIndex = 3;
                this._dgvRightsList.Columns["ParentLevelRightsName"].HeaderText = "父级权限";
                this._dgvRightsList.Columns["ParentLevelRightsName"].ToolTipText = "[只读列]";
                this._dgvRightsList.Columns["ParentLevelRightsName"].ReadOnly = true;
                this._dgvRightsList.Columns["ParentLevelRightsName"].DisplayIndex = 4;

                // 设置菜单分隔项的权限标题列为只读
                foreach (DataGridViewRow dgvRow in this._dgvRightsList.Rows)
                {
                    // 如果是菜单分隔项则设置为只读
                    if (dgvRow.Cells["RightsCaption"].Value.ToString().Trim() == "━━━━")
                        dgvRow.Cells["RightsCaption"].ReadOnly = true;

                    // 设置单元格工具栏提示
                    foreach (DataGridViewCell dgvCell in dgvRow.Cells)
                    {
                        if (dgvCell.ReadOnly)
                        {
                            dgvCell.ToolTipText = "[只读格]";
                            if (dgvCell.Value.ToString().Trim() == "━━━━")
                                dgvCell.ToolTipText += " | <-- 菜单分隔 -->";
                        }
                        else
                            dgvCell.ToolTipText = "[可写格]";
                    }
                }

                // 禁用关联选择
                RightsManagerUI.IsRelatingChooseCells = false;

                // 清除所有单元格选择
                _dgvRightsList.ClearSelection();

                // 还原原有选择
                foreach (string dgvSelectedCellValue in selectedCellValueList)
                {
                    foreach (DataGridViewRow dgvRow in _dgvRightsList.Rows)
                    {
                        foreach (DataGridViewCell dgvCell in dgvRow.Cells)
                        {
                            if (dgvCell.Value.ToString().Trim() == dgvSelectedCellValue)
                                dgvCell.Selected = true;
                        }
                    }
                }

                // 启用关联选择
                RightsManagerUI.IsRelatingChooseCells = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                ex.Message,
                "加载失败",
                MessageBoxButtons.OK,
                MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 将数据绑定加载到树形视图
        /// </summary>
        /// <param name="rightsCollection">权限集合</param>
        internal void BindDataToTreeView(Dictionary<string, Model.Rights> rightsCollection)
        {
            // 禁用树视图的重绘
            _tvRightsView.BeginUpdate();

            // 清除原有节点
            _tvRightsView.Nodes.Clear();

            // 遍历权限集合以加载数据
            foreach (Model.Rights tmpRights in rightsCollection.Values)
            {
                // 定义权限根项
                TreeNode rootTreeNode = null;

                // 如果是权限根项
                if (tmpRights.ParentLevelRightsName == _msMain.Name)
                {
                    rootTreeNode = new TreeNode(tmpRights.RightsCaption);
                    rootTreeNode.Tag = tmpRights.ModelName;
                    rootTreeNode.Checked = tmpRights.RightsState;
                    _tvRightsView.Nodes.Add(rootTreeNode);
                }
                // 如果是权限子项
                else
                {
                    // 创建权限子项
                    TreeNode childTreeNode = new TreeNode(tmpRights.RightsCaption);
                    childTreeNode.Tag = tmpRights.ModelName;
                    childTreeNode.Checked = tmpRights.RightsState;

                    // 将子项添加到对应的父项中
                    foreach (TreeNode tmpTreeNode in _tvRightsView.Nodes)
                    {
                        // 如果与现存的节点父级权限相同
                        if (tmpTreeNode.Tag.ToString() == tmpRights.ParentLevelRightsName)
                        {
                            // 递归添加所有层级子节点
                            tmpTreeNode.Nodes.Add(LoadAllChildTreeNode(childTreeNode, rightsCollection));
                        }
                    }
                }
            }

            // 展开所有树节点
            _tvRightsView.ExpandAll();

            // 启用树视图的重绘
            _tvRightsView.EndUpdate();
        }

        /// <summary>
        /// 选中/取消树节点及其子节点勾选状态
        /// </summary>
        /// <param name="currentTreeNode">当前操作的节点</param>
        internal void CheckOrUnCheckTreeNode(TreeNode currentTreeNode)
        {
            // 如果有选中单元格
            if (_dgvOperatorList.SelectedCells.Count > 0)
            {
                // 保存当前选中行的操作员名称
                string operatorName = _dgvOperatorList.Rows[_dgvOperatorList.SelectedCells[0].RowIndex].Cells["ModelName"].Value.ToString().Trim();
                // 同步权限状态
                RightsManagerUI.OperatorCollection[operatorName].RightsCollection[currentTreeNode.Tag.ToString()].RightsState = currentTreeNode.Checked;

                // 同时选中/取消子节点的勾选
                foreach (TreeNode childTreeNode in currentTreeNode.Nodes)
                {
                    // 同步子节点勾选状态
                    childTreeNode.Checked = currentTreeNode.Checked;
                    // 递归勾选下层子节点
                    CheckOrUnCheckTreeNode(childTreeNode);
                }
            }
        }

        /// <summary>
        /// 加载操作员列表
        /// </summary>
        internal void LoadOperatorList()
        {
            BLLFactory.BLLFactory bllFactory = new BLLFactory.BLLFactory();
            IBLL.IOperatorManager operatorManager = bllFactory.BuildOperatorManager();
            // 加载操作员列表
            try
            {
                RightsManagerUI.OperatorCollection = operatorManager.GetAllOperatorInfo();
                // 检查所有操作员的权限列表
                foreach (Model.Operator tmpOperator in RightsManagerUI.OperatorCollection.Values)
                {
                    // 如果权限为空就创建一个新的空权限集合
                    if (!(tmpOperator.RightsCollection is Dictionary<string, Model.Rights>))
                    {
                        tmpOperator.RightsCollection = new Dictionary<string, Model.Rights>();
                        // 创建权限管理类实例
                        Common.RightsMenuDataManager rmdManager = new Common.RightsMenuDataManager();
                        // 创建权限集合空结构
                        tmpOperator.RightsCollection = rmdManager.ReadMenuRightsItem(_msMain, tmpOperator.RightsCollection);
                    }
                }
                // 如果包含操作员信息
                if (RightsManagerUI.OperatorCollection.Count > 0)
                {
                    // 将操作员集合数据绑定显示到数据视图
                    BindOperatorInfoToDataGridView(RightsManagerUI.OperatorCollection);
                    // 重新指定当前登录操作员对象
                    foreach (Model.Operator tmpOperator in RightsManagerUI.OperatorCollection.Values)
                    {
                        if (tmpOperator.ModelName == RightsManagerUI.CurrentOperator.ModelName)
                        {
                            RightsManagerUI.CurrentOperator = RightsManagerUI.OperatorCollection[RightsManagerUI.CurrentOperator.ModelName];
                            // 将数据绑定显示到数据视图
                            BindDataToDataGridView(RightsManagerUI.CurrentOperator.RightsCollection);
                            // 将数据绑定加载到树形视图
                            BindDataToTreeView(RightsManagerUI.CurrentOperator.RightsCollection);

                            // 在操作员列表中选中当前操作员
                            foreach (DataGridViewRow dgvRow in _dgvOperatorList.Rows)
                            {
                                if (dgvRow.Cells["ModelName"].Value.ToString().Trim() == RightsManagerUI.CurrentOperator.ModelName)
                                {
                                    dgvRow.Selected = true;
                                    break;
                                }
                            }
                            break;
                        }
                    }
                }
                else
                {
                    // 清空操作员列表的数据行
                    DgvOperatorList.Rows.Clear();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                ex.Message,
                "加载失败",
                MessageBoxButtons.OK,
                MessageBoxIcon.Error);
            }
        }
        #endregion
    }
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

四、文章结语

 以上内容并未提供完整的源代码演示，仅仅提供一种解决此类问题的思路和方法。
 
 （一）技术难点
 
 1、将集合对象存储到数据库中（先使用序列化将集合对象流化，再将其转换为 Byte[] 数组）；
 2、使用递归法解析菜单对象及应用权限菜单项的权限设置（注意 MenuStrip 对象的第一层级的子项集合为 Items ，其余均为 DropDownItems ，所以在递归解析或应用设置时只能从第二层级的子项开始进行递归调用）；
 3、BindingSource 界面数据绑定对象 与 DataGridView 数据视图控件的配合使用（注意在绑定 Dictionary<Key, T> 泛型集合内容时，应直接将 BindingSource 的 DataSource 属性设置为该集合的 .Values 才能绑定到实际的内容）；
 4、TreeView 树形视图控件的使用（注意在增删树节点时应适当使用 BeginUpdate() 和 EndUpdate() 方法来防止闪屏问题）；
 5、隶属于多个权限组的操作员权限应为其所从属的多个权限组权限的并集（不算难，遍历一下集合即可）。

 （二）扩展思考
 
 此外，我所阐述的这种解决方案还可以再扩展一些人性化的功能。譬如本文没提及的一些人性化功能：
 
 1、让管理员用户完全自定义各个操作员的权限菜单标题（我已在自己的项目扩展此功能）；
 2、让权限菜单项在禁用时同时将该项的 Enabled 属性设置为 False ，以防止被隐藏的菜单项被快捷键呼出（太简单了，读者自己在上面的代码中添加少量代码即可实现）。
 3、让管理员自由选择使用基于用户或基于角色的权限管理方案（由于在操作员和权限组两个实体模型中都各自存储了自身的权限集合，所以，在这种相对松散的权限关系下，很容易实现此功能，此功能我也已在自己的项目中实现）。

启帆远航
关注
  • 4
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C# 用户权限管理
逸轩小雨的专栏
11-29 6457
int YongHuID = 0; int myop = 0; int KaiGuan = 0; DataTable dtPiPeiMoKuai = new DataTable(); BLL系统维护.frm_QuanXianSheZhi.frm_QuanXianSheZhiClient myfrm_QuanXianSheZhiClie
C#中的访问权限
ultramand的博客
02-07 1597
这些访问权限级别可以应用于类、结构、接口、成员变量、方法等。通过适当地选择访问权限，我们可以控制代码中的信息隐藏和封装，并确保只有必要的部分对外可见。在C#中，访问权限用于控制类、成员和其他程序实体的可访问性。C#提供了一些关键字来定义不同级别的访问权限，以确保适当的封装和信息隐藏。
c#通用版权限管理系统
03-18
主要功能有：权限管理、角色管理、部门管理、用户管理、公司管理、模块管理、系统设置。适用 OA、财务、人力等办公软件系统 的二次开发，以关键字（Key）的方式来定义系统的权限，使系统权限分配更加贴合企业需求。提供给开发人员使用，权限的控制需要与系统功能的实现挂接。 ● 权限管理界面，可以进行系统权限的定义操作。 ● 用户权限管理，对用户权限进行自定义设置，也可以继承其他用户、角色 等权限。 ● 角色权限管理，对角色权限进行自定义设置，也可以继承其他角色 等权限。 对系统进行模块化 可以设定公司的树状结构。 进行增、改、删、查 这是权限设置前的基础设置。
C# Winform 用户角色权限设置
最新发布
lvxingzhe3的博客
06-15 262
C# Winform 用户角色权限设置
【小白专用】（C#）用户、角色、权限控制体系
zgscwxd的博客
01-08 1309
（C#）用户、角色、权限
基于c#的权限管理的设计与实现-计算机毕业设计源码+LW文档
qq_375279829的博客
07-15 325
基于角色的权限管理，可以完整的描述权限的框架，将不同的用户拆分为不同的需求，使用起来更加的灵活，奠定了权限模型的发展。而对于权限管理可以开发出一个符合用户的通用的管理模块，本系统研究了基于角色的权限管理，提出不同的角色可以设置不同的权限，然后为用户赋予不同的角色来进行权限控制，并可以对功能模块的增删改查进行分别操作，提高权限管理的精细化控制，这样就可以将权限管理模块分离出来，进行单独开发，其它系统调用本系统的权限控制，满足各种业务需求。在开发过程中，力求系统的易用性、可维护性，具有很好的可扩展性。
C# .Net后台管理系统-权限管理
luojiayu42的博客
01-16 6705
C# .Net Core 权限管理系统
编写C#程序让其在Win7 下以管理员权限运行
changhu的专栏
07-28 1735
编写C#程序让其在Win7 下以管理员权限运行出处：西西整理 作者：西西 人气：559 次 评论: 0 | 我要发表看法Vista 和 Windows 7 操作系统为了加强安全，增加了 UAC(用户账户控制) 的机制，如果 UAC 被打开，用户即使是以管理员权限登录，其应用程序默
C#权限管理和设计浅谈
09-05
C#权限管理的设计不仅关乎安全性，还影响到系统的可扩展性和维护性。本篇文章将探讨权限管理的一些关键概念和设计策略。 首先，权限管理的核心目标是控制用户对系统资源的访问。这通常包括数据、功能、操作等方面的...
C#完整版权限管理系统
06-09
【标题】"C#完整版权限管理系统"是一个基于C#编程语言开发的高效且全面的权限管理解决方案。在Web应用程序框架中，权限管理是至关重要的组成部分，它涉及到用户角色分配、访问控制以及对系统资源的操作权限。这个...
c#权限管理系统.zip
03-15
本项目“c#权限管理系统”利用了C#编程语言，结合WPF（Windows Presentation Foundation）技术和MVVM（Model-View-ViewModel）设计模式，构建了一个高效且灵活的权限管理解决方案。 C#是一种由微软开发的面向对象的...
c#通用权限管理系统.zip
03-16
《C#通用权限管理系统详解》 在信息技术领域，权限管理是任何系统中不可或缺的一部分，它确保用户只能访问他们被授权的资源。C#作为一种广泛应用于Windows平台开发的编程语言，其丰富的特性和强大的库支持使得构建...
C#.NET C#的访问权限
as12628的博客
11-14 1756
c#的几种常用的访问修饰符 1、public：公共类型、完全公开、都能访问 2、private：私有类型、只要在类内部可以访问 3、protected ：受保护的类型、在类内部或继承访问 4、internal： 当前程序集可访问、同一个程序集目录下的文件 5、 protected internal 唯一的一种组合限制修饰符，它只可以被本组合体内所有的类和这些类的继承子类所存取。 c#默认访问权限和使用中的限制 1、类的默认是internal、类里面的所有的成员默认访问时private的 2、在namespa
数据权限的设计与思考
学海无涯，行者无疆
10-06 3798
权限控制是一个系统的核心功能，可以分为两类，一类是功能权限，一类是数据权限。数据权限又可以进一步分为行级权限和列级权限。功能权限，是指系统用户能进行哪些操作，通常是菜单和按钮权限，如打开订单菜单，查询订单列表，创建新订单。对于功能权限，有标准化的解决方案，也即RBAC，通过权限项、角色、用户三张主表，以及角色-权限项对应关系表和角色-用户对应关系表两张辅助表，一共5张库表即可实现功能权限的功能，系统管理员通过系统界面即可实现灵活的权限分配和维护。
数据权限设计思路_权限设计数据权限
Turn X7
06-22 1万+
任何一个系统中，都离不开权限的设计 权限设计 = 功能权限 + 数据权限+字段权限 【功能权限】：能做什么的问题。如查询、增删改信息【数据权限】：能看到哪些数据的问题。如查看本人、部门团队、区域或者整个公司、甚至整个系统的数据【字段权限】：能看到哪些信息的问题。如联系人姓名，但是不能查看到联系人地址、联系人电话这样的 1.功能权限设计 常常是基于RBAC(Role-Based Access Control)的一套设计方案 2.数据权限设计 2.1数据权限设计分析 ...
浅谈C# WinForm中实现基于角色的权限菜单
热门推荐
CodingMouse的专栏
12-14 1万+
浅谈C# WinForm中实现基于角色的权限菜单 作者：CodingMouse            日期：2008年12月14日 转载请注明文章来源：http://blog.csdn.net/CodingMouse/archive/2008/12/14/3515969.aspx 本博文完整源码已经上传，欢迎下载讨论：http://download.csdn.net/source/913
c#实现权限设置
S_myChild的博客
10-24 5114
做项目需要实现不同账号使用功能的限制，参考了一些资料。自己做了些整理，记录一下免得以后忘记了。 首先思路很重要，只有思路清晰了，才知道怎么去实现： （1）要有一个数据表去存放这些才能功能（定为A表），并且重要的是，这些存放在数据表A的菜单ID要和相对应功能窗体的·Tag对应这样在后边进行代码编写的时候才能做出判断。 （2）还需要一个数据表（B）来存放用户开放的权限 （3）就是将不同用户的功能权限设...
C# 工程添加管理员权限
m0_58124947的博客
02-02 1724
当你想用管理员方式运行代码的时候； 或再调用第三方控件的时候，会在自动生成的代码段报错的时候，选择管理员方式运行排除问题；
C#程序默认以管理员权限打开
凯神做开发
03-22 2311
1. 项目属性->安全性->启用ClickOnce安全设置 2. 找到requestedExecutionLevel节点，将level改为requireAdministrator 3. 先别着急编译程序，此时编译会报下图错误 严重性 代码 说明 项目 文件 行 禁止显示状态 错误 ClickOnce 不支持请求执行级别“requireAdministrator”。 ConsoleApplication1 ...
c# 开源权限管理框架
05-08
C是计算机科学中非常重要的编程语言之一，由贝尔实验室的丹尼斯·里奇在20世纪70年代初期创建。 C语言主要应用于系统软件和应用软件的开发，因为它能够直接访问计算机内存，且语法简单易学，效率高并且可移植性好。 在系统软件开发方面，C语言是操作系统开发的首选语言。比如UNIX、Linux、Windows等系统的开发都是使用C语言。在应用程序领域，C语言常被用于开发网络应用程序、数据库管理系统、编译器、模拟器、游戏引擎等高性能需求的软件。 此外，C语言也被广泛应用于嵌入式系统开发。例如，各种智能电器、智能手机、汽车电子、航空航天设备等都需要使用C语言进行开发。 虽然C语言在开发方面优势明显，但也存在一些缺陷。例如，C语言中缺乏面向对象编程的特点，对内存管理要求较高，容易出现内存溢出等问题，这些问题我们需要用更高级的语言进行完善和解决。 总的来说，C语言的发明和使用对计算机科学和编程语言产生了深远的影响，也为我们今后的计算机编程提供了很多有效的方法和思路。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值