启帆远航
启帆远航

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
{
    /// 
    ///  实体模型基类
    /// 
    [Serializable]
    public class ModelBase

    {
        #region Private Members

        int _id;
        string _modelName;

        #endregion

        #region Public Properties

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

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

        #region Public Methods

        /// 
        /// 无参构造
        /// 
        public ModelBase() { } 

        /// 
        /// 带参构造
        /// 
        /// 实体模型 ID
        /// 实体模型名称
        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
{
    /// 
    /// 操作员实体类
    /// 
    [Serializable]
    public class Operator : ModelBase
    {
        #region Private Members

        string _password;

        Dictionary<string, Rights> _rightsCollection;
        bool _state;

        #endregion

        #region Public Properties

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

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

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

        #region Public Methods

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

        /// 
        /// 带参构造
        /// 
        /// 操作员 ID
        /// 操作员名称
        /// 操作员密码
        /// 权限集合(键值用于存储菜单/工具栏项的 Name 属性)
        /// 操作员状态
        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
{
    /// 
    /// 权限组实体类
    /// 
    [Serializable]
    public class RightsGroup : ModelBase
    {
        #region Private Members

        Dictionary<string, Rights> _groupRightsCollection;

        #endregion

        #region Public Properties

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

        #region Public Methods

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

        /// 
        ///  带参构造
        /// 
        /// 权限组 ID
        /// 权限组名称
        /// 组权限集合
        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
{
    /// 
    /// 权限关系实体类
    /// 
    [Serializable]
    public class RightsRelation
    {
        #region Private Members

        int _id;

        int _operatorId;

        string _operatorName;

        int _rightsGroupId;

        string rightsGroupName;

        #endregion

        #region Public Properties

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

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

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

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

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

        #region Public Methods

        /// 
        /// 无参构造 
        /// 
        public RightsRelation() { }

        /// 
        /// 带参构造
        /// 
        /// 权限关系 ID
        /// 操作员 ID
        /// 操作员名称
        /// 权限组 ID
        /// 权限组名称
        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
{
    /// 
    /// 操作员数据访问操作类
    /// 
    public class OperatorService : IDAL.IOperatorService
    {
        #region IOperatorService 成员

        /// 
        /// 根据操作员名称和密码获取操作员实体
        /// 
        /// 操作员名称
        /// 操作员密码
        /// 操作员实体
        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;
        }

        /// 
        /// 添加操作员
        /// 
        /// 要添加的操作员实体
        /// True:成功/False:失败
        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;
            }
        }

        /// 
        /// 删除操作员
        /// 
        /// 要删除的操作员 ID
        /// True:成功/False:失败
        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;
            }
        }

        /// 
        /// 获取所有操作员信息
        /// 
        /// 操作员实体集合
        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;
        }

        /// 
        /// 根据操作员名称校验操作员是否存在
        /// 
        /// 操作员名称
        /// True:存在/Flase:不存在
        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
 {
  ///  
  /// 权限组数据访问操作类 
  ///  
  public class RightsGroupService : IDAL.IRightsGroupService
  { 
   #region IRightsGroupService 成员 

   ///  
   /// 获取所有权限组信息 
   ///  
   /// 权限组实体集合 
   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;
   }

   ///  
   /// 添加权限组 
   ///  
   /// 要添加的权限组实体 
   /// True:成功/False:失败 
   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;
    }
   }

   ///  
   /// 删除权限组 
   ///  
   /// 要删除的权限组 ID 
   /// True:成功/False:失败 
   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;
   }

   ///  
   /// 修改权限组 
   ///  
   /// 要修改的权限组实体 
   /// True:成功/False:失败 
   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;
    }
   }

   ///  
   /// 根据权限组名称校验权限组是否已经存在 
   ///  
   /// 权限组名称 
   /// True:存在/False:不存在 
   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
{
    /// 
    /// 权限关系数据访问操作类
    /// 
    public class RightsRelationService : IDAL.IRightsRelationService
    {
        #region IRightsRelationService 成员

        /// 
        /// 添加单个权限关系
        /// 
        /// 权限关系实体
        /// True:成功/False:失败
        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;
            }
        }

        /// 
        /// 根据权限关系 ID 删除权限关系
        /// 
        /// 权限关系 ID
        ///  True:成功/False:失败
        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;
        }

        /// 
        /// 根据操作员 ID 删除对应的所有权限关系
        /// 
        /// 操作员 ID
        /// True:成功/False:失败
        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;
        }

        /// 
        /// 修改单个权限关系
        /// 
        /// 权限关系实体
        /// True:成功/False:失败
        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;
            }
        }

        /// 
        /// 获取所有的权限关系集合
        /// 
        /// 权限关系集合
        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;
        }

        /// 
        /// 根据操作员 ID 获取对应的所有权限关系
        /// 
        /// 操作员 ID
        /// 权限关系集合
        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;
        }

        /// 
        /// 根据权限组 ID 获取与此权限组相关的权限关系数量
        /// 
        /// 权限组 ID
        /// 权限关系数量
        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
{
    /// 
    /// 操作员数据访问操作类
    /// 
    public class OperatorManager : IBLL.IOperatorManager
    {
        #region IOperatorManager 成员

        /// 
        /// 根据操作员名称和密码获取操作员实体
        /// 
        /// 操作员名称
        /// 操作员密码
        /// 操作员实体
        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);
        }

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

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

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

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

        /// 
        /// 根据操作员名称校验操作员是否存在
        /// 
        /// 操作员名称
        /// True:存在/Flase:不存在
        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
{
    /// 
    /// 权限组数据访问操作类
    /// 
    public class RightsGroupManager : IBLL.IRightsGroupManager
    {
        #region IRightsGroupManager 成员

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

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

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

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

        /// 
        /// 根据权限组名称校验权限组是否已经存在
        /// 
        /// 权限组名称
        /// True:存在/False:不存在
        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
{
    /// 
    /// 权限关系数据访问操作类
    /// 
    public class RightsRelationManager : IBLL.IRightsRelationManager
    {
        #region IRightsRelationManager 成员

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

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

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

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

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

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

        /// 
        /// 根据权限组 ID 获取与此权限组相关的权限关系数量
        /// 
        /// 权限组 ID
        /// 权限关系数量
        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
{

    /// 
    /// 权限菜单数据管理类
    /// 
    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

        /// 
        ///  使用递归法读取菜单权限子项
        /// 
        /// 要保存到的菜单根项权限集合
        /// 当前菜单权限相对根项
        /// 
        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;
        }

        /// 
        /// 使用递归法加载菜单权限子项
        /// 
        /// 权限集合
        /// 当前菜单权限相对根项
        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

        /// 
        /// 使用递归法读取菜单权限项
        /// 
        /// 要保存到的目标权限集合
        /// 权限集合
        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);
        }

        /// 
        /// 使用递归法读取菜单权限项
        /// 
        /// 当前被管理的菜单对象
        /// 要保存到的目标权限集合
        /// 权限集合
        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);
        }

        /// 
        /// 使用递归法加载菜单权限项
        /// 
        /// 当前被管理的菜单对象
        ///  权限集合
        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
{
    /// 
    /// 权限菜单界面管理类
    /// 
    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

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

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

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

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

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

        #region Private Methods

        /// 
        /// 加载所有树子节点
        /// 
        /// 当前子节点
        /// 所有权限集合
        /// 
        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

        /// 
        /// 将操作员集合数据绑定显示到数据视图
        /// 
        /// 操作员集合
        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);
            }
        }

        /// 
        /// 将权限集合数据绑定显示到数据视图
        /// 
        /// 权限集合
        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);
            }
        }

        /// 
        /// 将数据绑定加载到树形视图
        /// 
        /// 权限集合
        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();
        }

        /// 
        /// 选中/取消树节点及其子节点勾选状态
        /// 
        /// 当前操作的节点
        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);
                }
            }
        }

        /// 
        /// 加载操作员列表
        /// 
        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 泛型集合内容时，应直接将 BindingSource 的 DataSource 属性设置为该集合的 .Values 才能绑定到实际的内容）；
 4、TreeView 树形视图控件的使用（注意在增删树节点时应适当使用 BeginUpdate() 和 EndUpdate() 方法来防止闪屏问题）；
 5、隶属于多个权限组的操作员权限应为其所从属的多个权限组权限的并集（不算难，遍历一下集合即可）。

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

你可能感兴趣的:(C#)

  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • 你可能遗漏的一些C#/.NET/.NET Core知识点 追逐时光者 C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
  • C#动态加载DLL程序集及使用反射创建实例-简记 不全 C#相关Asp.netWebFormAsp.netMVCc#Assembly反射程序集
    Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • python可以制作大型游戏_python能做游戏吗-python能开发游戏吗 靖dede python可以制作大型游戏
    python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
  • 【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园c#开发语言
    C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
  • Lua 与 C#交互 z2014z luac#开发语言
    Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • C# 禁止程序重复启动 wiseyao1219 c#
    修改：Program.cs[STAThread]staticvoidMain(){Mutexmutex=newMutex(true,"NewGuid123456",outboolisCreatedNew);if(!isCreatedNew){MessageBox.Show(Application.ProductName+"isrunning...");return;}Application.Ena
  • C#中判断socket是否已断开的方法 wiseyao1219 c#
    代码如下：Sockets=newSocket(..);if(s.Poll(-1,SelectMode.SelectRead)){intnRead=s.Receive();if(nRead==0){//socket连接已断开}}参考：C#中判断socket是否已断开的方法
  • C#文件被占用的解决方案 花北城 C#项目文件占用
    问题打更新包时，提示文件被占用。System.IO.IOException:文件“D:\RS\RS_CCVI20111210.exe”正由另一进程使用，因此该进程无法访问该文件。在System.IO.__Error.WinIOError(Int32errorCode,StringmaybeFullPath)在System.IO.FileStream.Init(Stringpath,FileMode
  • C#实现软件自动升级 BruceEditCode
    winform程序相对web程序而言，功能更强大，编程更方便，但软件更新却相当麻烦，要到客户端一台一台地升级，本文结合实际情况，通过软件实现自动升级，弥补了这一缺陷，有较好的参考价值。由于程序在运行时不能用新的版本覆盖自己，因此，我们将登录窗口单独做成一个可执行文件，用户登录时，从网上检测是否有新的主程序，如果有，则从后台下载并覆盖老的版本，用户输入正确的用户名和密码后，通过参数将必要的信息（如用
  • C# 自动化 TineAine C#代码片段自动化c#自动化模拟操作
    实现的方法可能很笨，但是确实很好用usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Runtime.InteropServices;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;/******************
  • 技术周总结 09.09~09.15周日(C# WinForm WPF) 打破砂锅问到底007 wpfc#WinForm
    文章目录一、09.09周一1.1)问题01:Windows桌面开发中，WPF和WinForm的区别和联系？联系：区别：二、09.12周四2.1）问题01：visualstudio的相关快捷键有哪些？通用快捷键编辑导航调试窗口管理2.2）问题02：publicpartialclassChoosePLReason:CommonBaseForm2.3)问题03：介绍WindowsForms中的Syste
  • 通过C# 裁剪PDF页面 Eiceblue C#.NETPDFc#pdf开发语言visualstudio
    在处理PDF文档时，有时需要精确地裁剪页面以适应特定需求，比如去除广告、背景信息或者仅仅是为了简化文档内容。本文将指导如何使用免费.NET控件通过C#实现裁剪PDF页面。免费库FreeSpire.PDFfor.NET支持在.NET(C#,VB.NET,ASP.NET,.NETCore)程序中实现创建、操作、转换和打印PDF文档等操作。可以从以下链接下载产品包后手动添加引用，或者直接通过NuGet安
  • 【Unity基础】如何选择脚本编译方式Mono和IL2CPP？ tealcwu Unity基础unity游戏引擎
    Edit->ProjectSettings->Player在Unity中，ScriptingBackend决定了项目的脚本编译方式，即如何将C#代码转换为可执行代码。Unity提供了两种主要的ScriptingBackend选项：Mono和IL2CPP。它们之间的区别影响了项目的性能、平台支持、编译时间和调试体验。以下是两者的详细对比：1.Mono简介:Mono是Unity最早使用的脚本后端，基于
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • C# Linq语句用法大全以及Lambda表达式 一个小码码 c#linq开发语言.net
    C#Linq语句用法大全以及Lambda表达式Linq：是一种用于数据查询和操作的语言集成查询（LanguageIntegratedQuery）技术。通过Linq，我们可以使用类似于SQL查询的方式来查询、筛选和操作各种类型的数据集合，包括数组、列表、集合、XML文档、数据库表等等。常见的有：LinqtoObjects：用于操作对象集合，例如数组、列表等。LinqtoXML：用于操作XML数据，支
  • C#中的LInq语句 weixin_30588907 c#数据库
    语言集成查询(LINQ)是一组技术的名称，这些技术建立在将查询功能直接集成到C#语言（以及VisualBasic和可能的任何其他.NET语言）的基础上。借助于LINQ，查询现在已是高级语言构造，就如同类、方法、事件等等。对于编写查询的开发人员来说，LINQ最明显的“语言集成”部分是查询表达式。查询表达式是使用C#3.0中引入的声明性查询语法编写的。通过使用查询语法，您甚至可以使用最少的代码对数据源
  • C#的linq语句 木生火18624 C#开发
    /查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
  • C# 多线程操作同一个文件，如何避免冲突 FlYFlOWERANDLEAF c#开发语言
    1使用lock经测试，依然存在线程冲突privatestaticobjectlocker=newobject();……lock(locker){stringbText=File.ReadAllText(FPath);returnbText;}……lock(locker){File.WriteAllText(FPath,aContent);}2使用ReaderWriterLockSlim经测试，依然
  • C#LINQ常用扩展语句 月落. C#c#linqsolr
    在C#中，LINQ提供了许多扩展方法，这些方法定义在System.Linq命名空间中。以下是一些常用的LINQ扩展方法：Where-过滤数据集合，返回满足条件的元素。varfilteredItems=collection.Where(item=>item.SomeProperty>10);Select-从数据集合中选择数据或创建新的投影。varprojectedItems=collection.S
  • source insight4.0中文乱码解决方法 鹿屿二向箔 c语言stm32keilmdk
    Sourceinsight是强大、顺手的代码编辑器，它几乎支持所有的语言，包括：C，C++，C#，HTML等等，能够自动创建并维护它自己高性能的符号数据库，包括函数、全局变量、结构、类和工程源文件里定义的其它类型的符号，对于大工程的源码阅读非常方便。但是因为是国外软件，对中文支持不是很好，很多电脑安装使用都会出现注释乱码问题，很让人抓狂。网上很多人遇到类似的问题，也有很多解决方式，也有很多“终极解
  • C#基础知识-.NET，变量，容量单位，数据类型 yi碗汤园 c#开发语言
    目录1.NET简介2.变量1）定义2）声明3）赋值3.容量单位4.数据类型1）整形(整数)2）非整型(小数)3）非数值型本篇文章来分享一下C#的基础知识，主要讲述一下变量和数据类型的相关知识。1.NET简介.NETdonet是Microsoft新一代多语言的开发平台，用于构建和运行应用程序。Unity借助Mono实现跨平台，核心是.NETFramework框架。2.变量1）什么是变量变量是用来存储
  • C# 在WPF中实现图表生成 A_nanda WPF赏析c#wpf开发语言
    在现代应用程序中，数据可视化是一个重要的功能，它可以帮助用户更直观地理解数据。在C#WPF（WindowsPresentationFoundation）中，有多种方式可以生成图表。以下是五种常见的方法，每种方法都有其独特的优势和局限。1.使用System.Windows.Shapes命名空间代码示例：<RectangleWidth="50"Height="50"Fill="Blue"Canva
  • C#中关闭窗口清除内容 Vae_Mars AI对话中的其他知识c#开发语言
    1.解释说明-窗口关闭时是可以执行函数的，可以做一部分事件处理-因为删除文件夹的方案不好做，所以改成清空文件夹内的内容2.程序示例publicMainWindow(){InitializeComponent();//检查窗口关闭this.Closing+=MainWindow_Closing;}//执行具体的方法privatevoidMainWindow_Closing(objectsender,
  • C#中Invoke的用法（） 世界太过浮夸 .netc#
    转自：http://www.cnblogs.com/lsgsanxiao/p/5523282.htmlinvoke和begininvoke区别一直对invoke和begininvoke的使用和概念比较混乱，这两天看了些资料，对这两个的用法和原理有了些新的认识和理解。首先说下，invoke和begininvoke的使用有两种情况：control中的invoke、begininvoke。delegra
  • .NET常见面试题汇总 .Net Core 爱好者 .netc#
    首先，汇总一共分为三部分：一是关于.NET技术的面试问题，二是关于.NET项目中的实际问题，三是历年出现过一些面试题汇总一、.NET技术面试问题请简述.NET中的装箱和拆箱。什么是泛型，以及它在.NET中的用途？请解释一下C#中的委托是什么，以及它们如何工作？什么是事件，如何使用它们？请解释一下C#中的特性(Attributes)及其应用场景。.NET中的异步编程模式有哪些？什么是LINQ，它在.
  • c# net8调用vc写的dll wiseyao1219 c#开发语言dll
    dll程序（vc,x86)头文件extern"C"int__declspec(dllexport)WINAPIadd(inta,intb);实现intWINAPIadd(inta,intb){returna+b;}c#/net8函数声明：[DllImport("dll/Dll1.dll",CallingConvention=CallingConvention.StdCall)]publicstat
  • c# json使用 wiseyao1219 c#json前端
    安装包用NuGet安装包：Newtonsoft.Json对象转为Json字符串publicclassPerson{publicstringName{get;set;}publicintAge{get;set;}}Personperson=newPerson{Name="JohnDoe",Age=30};stringjson2=JsonConvert.SerializeObject(person);
  • web报表工具FineReport常见的数据集报错错误代码和解释 老A不折腾 web报表finereport代码可视化工具
    在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。   NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
  • Java的WeakReference与WeakHashMap bylijinnan java弱引用
    首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
  • Linux——（hostname）主机名与ip的映射 eksliang linuxhostname
    一、 什么是主机名 无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的； 主机名是用于什么的呢？ 答：在一个局域网中，每台机器都有一个主
  • oracle 常用技巧 18289753290
    oracle常用技巧 ①复制表结构和数据   create table  temp_clientloginUser as   select distinct userid from tbusrtloginlog ②仅复制数据 如果表结构一样 insert into  mytable  select  * &nb
  • 使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
    有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
  • IT系统分析师如何学习大数据 蓝儿唯美 大数据
    我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系 统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
  • spring学习——简介 a-john spring
    Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
  • 自定义颜色的xml文件 aijuans xml
    <?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
  • 运营到底是做什么的？ aoyouzi 运营到底是做什么的？
    文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
  • js面向对象类和对象 百合不是茶 js面向对象函数创建类和对象
    接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言 但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下  ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似   下面介绍一些js的类和对象的创建的技术   一:类和对
  • web.xml之资源管理对象配置 resource-env-ref bijian1013 javaweb.xmlservlet
    resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
  • Create a composite component with a custom namespace sunjing
    https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace   When you developed a composite component the namespace you would be seeing would
  • 【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
     一、复本集为什么要加入Arbiter这个角色 回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。 什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
  • Javascript开发笔记 白糖_ JavaScript
    获取iframe内的元素 通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
  • Web浏览器Chrome打开一段时间后，运行alert无效 bozch Webchormealert无效
    今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。 试了试其他浏览器，发现都是没有问题的。 开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。 这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了 就关闭浏览器重启。   结果就好了，这也太怪异了。难道是cho
  • 编程之美-高效地安排会议 图着色问题 贪心算法 bylijinnan 编程之美
    import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美 高效地安排会议 图着色问题 贪心算法 * 假设要用很多个教室对一组
  • 机器学习相关概念和开发工具 chenbowen00 算法matlab机器学习
    基本概念： 机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。 它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。 开发工具 M
  • [宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
           大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........        所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
  • oracle 11g database control 证书错误 daizj oracle证书错误oracle 11G 安装
    oracle 11g database control 证书错误  win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面 解决办法： 是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
  • Java I/O之用FilenameFilter实现根据文件扩展名删除文件 游其是你 FilenameFilter
    在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。 在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  • C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com carray
    # include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
  • PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。 就是 唯一 且 不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
    PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。 就是 唯一 且 不能为空。INDEX 索引，普通的UNIQUE 唯一索引。 不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号   INT会员姓名  
  • java集合辅助类 Collections、Arrays shuizhaosi888 CollectionsArraysHashCode
      Arrays、Collections   1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }      a）Arrays.asL
  • Spring Security（10）——退出登录logout 234390216 logoutSpring Security退出登录logout-urlLogoutFilter
           要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
  • 透过源码学前端 之 Backbone 三 Model 逐行分析JS源代码 backbone源码分析js学习
    Backbone 分析第三部分  Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里， 但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件， 如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
  • SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
    这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
  • 分布式基础知识和算法理论 bluky999 算法zookeeper分布式一致性哈希paxos
      分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218   在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
  • Android Studio的.gitignore以及gitignore无效的解决 bell0901 androidgitignore
    　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了 　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
  • 成为高级程序员的10个步骤 tomcat_oracle 编程
    What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。   Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加 提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进 历经更大的挑战。随着你的成长，各种影响力也会提高。
  • mongdb在linux下的安装 xtuhcy mongodblinux
    一、查询linux版本号： lsb_release -a  LSB Version:    :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他