项目常用解决方案之SystemSetting.xml文件的修改与读取

Winform及WPF项目中经常会用到类似SystemSetting.xml等类似的文件用于保存CLIENT的数据，比如登录过的用户名或密码以及其他设置。所以就想到一个解决方法，可以用到所有有此需求的项目中去，避免重复写代码。

1.创建一个Attribute类，用于指定属性在XML文件中的Path

  public class NodePathAttribute : Attribute
    {
        public string NodePath
        {
            get;
            set;
        }

        public string DefaultValue
        {
            get; 
            set;
        }

        public NodePathAttribute(string nodePath)
        {
            NodePath = nodePath;
        }

        public NodePathAttribute(string nodePath,string defaultValue)
            :this(nodePath)
        {
            DefaultValue = defaultValue;
        }
    }

2.SystemSetting类用于定义要读取和保存的属性，SystemSetting继续XMLSettingBase

namespace ConsoleApplication2
{
    public class SystemSetting : XMLSettingBase
    {
        #region Property

        #region HostLocationSetting

        /// <summary>
        /// host wcf service location
        /// </summary>
        [NodePath("/Settings/HostLocationSetting/HostLocation")]
        public string HostLocation { get; set; }

        /// <summary>
        /// host wcf service port
        /// </summary>
        [NodePath("/Settings/HostLocationSetting/HostPort")]
        public int? HostPort { get; set; }

        #endregion

        #region SystemFolderSetting

        /// <summary>
        /// NiceLable sdk niceengine5wr.dll path
        /// </summary>
        [NodePath("/Settings/SystemFolderSetting/NiceEngineFolderPath")]
        public string NiceEngineFolderPath
        {
            get;
            set;
        }

        #endregion

        #region SearchSetting

        /// <summary>
        /// Main program
        /// </summary>
        [NodePath("/Settings/SearchSetting/MainProgram")]
        public string MainProgram
        {
            get;
            set;
        }

        /// <summary>
        /// Sub program
        /// </summary>
        [NodePath("/Settings/SearchSetting/SubProgram")]
        public string SubProgram
        { 
            get; 
            set; 
        }

        /// <summary>
        /// Get/Set Date Range to auto setting and search condition
        /// </summary>
        [NodePath("/Settings/SearchSetting/DateRange")]
        public int? DateRange
        {
            get; 
            set;
        }

        /// <summary>
        /// Get/Set Date Range unit 0：days;1:weeks;2:months;3:years
        /// </summary>
        [NodePath("/Settings/SearchSetting/DateRangeUnit")]
        public int? DateRangeUnit 
        {
            get;
            set;
        }

        /// <summary>
        /// search status
        /// </summary>
        [NodePath("/Settings/SearchSetting/Status")]
        public FileStatus? Status 
        {
            get; 
            set;
        }

        /// <summary>
        /// Skip printed order
        /// </summary>
        [NodePath("/Settings/SearchSetting/SkipPrintedOrder")]
        public bool? SkipPrintedOrder
        {
            get;
            set;
        }

        #endregion

        #region PrintSetting

        [NodePath("/Settings/PrintSetting/ReturnQCResult")]
        public bool? ReturnQCResult { get; set; }

        [NodePath("/Settings/PrintSetting/ActualPrintQuantity")]
        public bool? ActualPrintQuantity { get; set; }

        [NodePath("/Settings/PrintSetting/MOSeperator")]
        public bool? MOSeperator { get; set; }

        [NodePath("/Settings/PrintSetting/SKUSeperator")]
        public string SKUSeperator { get; set; }

        #endregion

        #region LoginSetting

        [NodePath("/Settings/LoginSetting/UserName")]
        public string UserName { get; set; }

        [NodePath("/Settings/LoginSetting/Password")]
        public string Password { get; set; }

        [NodePath("/Settings/LoginSetting/Language")]
        public string Language { get; set; }

        #endregion

        #endregion

        #region Ctor

        public SystemSetting(string filePath) 
            :base(filePath)
        {
        
        }

        #endregion
    }
}

public class XMLSettingBase
    {
        #region Field

        protected string _filePath = null;
        protected XmlDocument _xmlDocument = null;

        public delegate void SettingChange();

        #endregion

        #region Ctor

        public XMLSettingBase(string filePath)
        {
            _filePath = filePath;
            _xmlDocument = new XmlDocument();
            _xmlDocument.Load(filePath);
        }

        #endregion

        #region Event

        public event SettingChange OnSettingChangeEvent;

        #endregion

        #region Method

        /// <summary>
        /// init system setting
        /// </summary>
        public void LoadData()
        {
            PropertyInfo[] propertyInfoes = this.GetType().GetProperties();
            if (propertyInfoes == null && propertyInfoes.Length == 0) { return; }

            //load each setting value
            foreach (var propertyInfo in propertyInfoes)
            {
                NodePathAttribute customerAttribute = propertyInfo.GetCustomAttribute<NodePathAttribute>();

                if (customerAttribute == null) { continue; }

                string propertyValue = string.Empty;
                if (_xmlDocument.SelectSingleNode(customerAttribute.NodePath) != null)
                {
                    propertyValue = GetXmlNodeValue(customerAttribute.NodePath);
                }
                else
                {
                    CreateNode(customerAttribute.NodePath);

                    propertyValue = customerAttribute.DefaultValue;
                }

                //whether need to decrypt value
                EncryptAttribute encryptAttribute = propertyInfo.GetCustomAttribute<EncryptAttribute>();
                if (encryptAttribute == null)
                {
                    SetPropertyInfoValue(propertyInfo, this, propertyValue);
                }
                else
                {
                    SetPropertyInfoValue(propertyInfo, this, Decrypt(propertyValue, encryptAttribute.EncryptPassword));
                }

            }

            LoadExtendData();
        }

        public virtual void LoadExtendData()
        {
            return;
        }

        /// <summary>
        /// save data to xml file.
        /// </summary>
        public void SaveData()
        {
            PropertyInfo[] propertyInfoes = this.GetType().GetProperties();
            if (propertyInfoes == null && propertyInfoes.Length == 0) { return; }

            //load each setting value
            foreach (var propertyInfo in propertyInfoes)
            {
                NodePathAttribute customerAttribute = propertyInfo.GetCustomAttribute<NodePathAttribute>();

                if (customerAttribute == null) { continue; }

                object propertyValue = propertyInfo.GetValue(this);

                //whether need to decrypt value
                EncryptAttribute encryptAttribute = propertyInfo.GetCustomAttribute<EncryptAttribute>();
                if (encryptAttribute == null)
                {
                    SetXmlNodeValue(customerAttribute.NodePath, propertyValue != null ? propertyValue.ToString() : string.Empty);
                }
                else
                {
                    SetXmlNodeValue(customerAttribute.NodePath, propertyValue != null ? Encrypt(propertyValue.ToString(), encryptAttribute.EncryptPassword) : string.Empty);
                }
            }

            _xmlDocument.Save(_filePath);
        }

        /// <summary>
        /// refresh system setting
        /// </summary>
        public void Refresh()
        {
            //save data
            SaveData();
            //reload the data.
            LoadData();
            //triggering event
            if (OnSettingChangeEvent != null)
            {
                OnSettingChangeEvent();
            }
        }

        public string GetXmlNodeValue(string strNode)
        {
            try
            {
                XmlNode xmlNode = _xmlDocument.SelectSingleNode(strNode);
                return xmlNode.InnerText;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void SetXmlNodeValue(string strNode, string value)
        {
            try
            {
                XmlNode xmlNode = _xmlDocument.SelectSingleNode(strNode);
                xmlNode.InnerText = value;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// convert the datatable to list
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        private void SetPropertyInfoValue(PropertyInfo propertyInfo, object obj, object value)
        {
            //check value
            if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
            {
                return;
            }

            string strValue = value.ToString();

            if (propertyInfo.PropertyType.IsEnum)
            {
                propertyInfo.SetValue(obj, Enum.Parse(propertyInfo.PropertyType, strValue), null);
            }
            else
            {
                string propertyTypeName = propertyInfo.PropertyType.Name;
                switch (propertyTypeName)
                {
                    case "Int32":
                    case "Int64":
                    case "Int":
                        int intValue;
                        int.TryParse(strValue, out intValue);
                        propertyInfo.SetValue(obj, intValue, null);
                        break;
                    case "Long":
                        long longValue;
                        long.TryParse(strValue, out longValue);
                        propertyInfo.SetValue(obj, longValue, null);
                        break;
                    case "DateTime":
                        DateTime dateTime;
                        DateTime.TryParse(strValue, out dateTime);
                        propertyInfo.SetValue(obj, dateTime, null);
                        break;
                    case "Boolean":
                        Boolean bv = false;
                        if ("1".Equals(value) || "true".Equals(strValue.ToLower()))
                        {
                            bv = true;
                        }
                        propertyInfo.SetValue(obj, bv, null);
                        break;
                    case "Nullable`1":
                        if (propertyInfo.PropertyType.GenericTypeArguments[0].IsEnum)
                        {
                            propertyInfo.SetValue(obj, Enum.Parse(propertyInfo.PropertyType.GenericTypeArguments[0], strValue), null);
                        }
                        else
                        {
                            switch (propertyInfo.PropertyType.GenericTypeArguments[0].FullName)
                            {
                                case "System.Int32":
                                case "System.Int64":
                                case "System.Int":
                                    int intV;
                                    int.TryParse(strValue, out intV);
                                    propertyInfo.SetValue(obj, intV, null);
                                    break;
                                case "System.DateTime":
                                    DateTime dtime;
                                    DateTime.TryParse(strValue, out dtime);
                                    propertyInfo.SetValue(obj, dtime, null);
                                    break;
                                case "System.Boolean":
                                    Boolean boolv = false;
                                    if ("1".Equals(value) || "true".Equals(strValue.ToLower()))
                                    {
                                        boolv = true;
                                    }
                                    propertyInfo.SetValue(obj, boolv, null);
                                    break;
                                default:
                                    propertyInfo.SetValue(obj, strValue, null);
                                    break;
                            }
                        }
                        break;
                    default:
                        propertyInfo.SetValue(obj, strValue, null);
                        break;
                }

            }
        }

        /// <summary>
        /// Decrypt text
        /// </summary>
        /// <param name="value"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        private string Decrypt(string value, string password)
        {
            Encryption encryption = new Encryption();
            string outMsg = null;
            //Decrypt
            if (!string.IsNullOrEmpty(value))
            {
                encryption.DesDecrypt(value, password, out outMsg);
            }

            return outMsg;

        }

        /// <summary>
        /// Enctypr text
        /// </summary>
        /// <param name="value"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        private string Encrypt(string value, string password)
        {
            Encryption encryption = new Encryption();
            string outMsg = null;

            if (encryption.DesEncrypt(value, password, out outMsg))
            {
                return outMsg;
            }
            else
            {
                return string.Empty;
            }

        }

        public void CreateNode(string strNode)
        {
            string[] nodes = strNode.Split(new[] { @"/" }, StringSplitOptions.RemoveEmptyEntries);

            var tempNode = new StringBuilder();
            for (int i = 0; i < nodes.Length; i++)
            {
                string parentNodePath = tempNode.ToString();

                tempNode.Append(@"/");

                tempNode.Append(nodes[i]);

                //此节点不存在，则创建此结点
                if (_xmlDocument.SelectSingleNode(tempNode.ToString()) == null)
                {
                    XmlNode newNode = _xmlDocument.CreateElement(nodes[i]);

                    //寻找父结点
                    XmlNode parentNode = _xmlDocument.SelectSingleNode(parentNodePath);

                    if (parentNode != null)
                    {
                        parentNode.AppendChild(newNode);
                    }
                }
            }

            _xmlDocument.Save(_filePath);
        }

        #endregion

    }

3.测试用类

这是需要操作的文件
<?xml version="1.0" encoding="utf-8" ?>
<Settings>
  <HostLocationSetting>
    <HostLocation></HostLocation>
    <HostPort></HostPort>
  </HostLocationSetting>
  <SystemFolderSetting>
    <NiceEngineFolderPath></NiceEngineFolderPath>
  </SystemFolderSetting>
  <SearchSetting>
    <MainProgram></MainProgram>
    <SubProgram></SubProgram>
    <Status></Status>
    <SkipPrintedOrder>true</SkipPrintedOrder>
    <DateRange>1</DateRange>
    <DateRangeUnit>0</DateRangeUnit>
  </SearchSetting>
  <PrintSetting>
    <ReturnQCResult>false</ReturnQCResult>
    <ActualPrintQuantity></ActualPrintQuantity>
    <MOSeperator>true</MOSeperator>
    <SKUSeperator></SKUSeperator>
  </PrintSetting>
  <LoginSetting>
    <UserName></UserName>
    <Password></Password>
    <Language></Language>
  </LoginSetting>

</Settings>


测试代码如下
namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            SystemSetting systemSetting = new SystemSetting(@"Config/SystemSetting.xml");

            systemSetting.LoadData();

            Console.WriteLine(systemSetting.HostLocation);
            Console.WriteLine(systemSetting.Status);
            Console.WriteLine(systemSetting.SkipPrintedOrder);

            systemSetting.HostLocation = "192.168.15.171";
            systemSetting.Status = FileStatus.PARTIAL_PRINTED;
            systemSetting.SkipPrintedOrder = true;

            systemSetting.Refresh();

            systemSetting.LoadData();

            Console.WriteLine(systemSetting.HostLocation);
            Console.WriteLine(systemSetting.Status);
            Console.WriteLine(systemSetting.SkipPrintedOrder);

            Console.ReadKey();

        }
    }
}