将应用程序中的一些参数写到xml配置文件中

最近碰到一个问题，需要将程序中的一些基本参数写到xml文件中，虽然网上有好多现成的代码，但是觉得对xml不熟悉，果断就研究了一下。先说一下大体思路吧，我设计了一个用来读取和回填的类，然后定义了一个接口，和一个Attribute，之后就是继承该接口的若干个子类，列表如下：

      1.用来读取xml和回填实体对象的类:ProgramSettings;

      2.需要实现的接口:SettingsEntity;

      3.用来约束类中那些属性不需要写入文件的Attribute:DontFill;

      4.一个实现了接口的子类:SettingsEntity.

以下是代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml;
using System.Configuration;
using System.Reflection;
using WinControl;
using LogSystem;

namespace WirelessQAR
{
    /*
     *wanglei 2016/2/25 创建 用来保存程序设置到根目录下面的xml文件，在程序加载时进行读取
     * 使用单体模式-饱汉模式
     */
    public class ProgramSettings
    {
        private static ProgramSettings _programSettings = new ProgramSettings();

        private  string _path = Environment.CurrentDirectory + "\" + ConfigurationSettings.AppSettings["BaseSetting"];

        private ProgramSettings()
        {

        }

        //确保能够得到符合标准的XMLDocument
        private XmlDocument ReadXmlData(string path)
        {
            XmlDocument xmlDoc = new XmlDocument();
            try
            {
                if (!File.Exists(_path))
                {
                    FileStream fileStream = File.Create(_path);
                    StreamWriter streamWriter = new StreamWriter(fileStream);
                    streamWriter.Write("<root></root>");
                    streamWriter.Flush();
                    streamWriter.Close();
                    xmlDoc.Load(_path);
                }
                else
                {
                    xmlDoc.Load(path);
                }
            }
            catch (Exception ex)
            {
              //记录日志或者提示出信息 53             }

            if (xmlDoc.DocumentElement == null)
            {
                if (File.Exists(_path))
                {
                    StreamReader streamReader = File.OpenText(_path);
                    string copy = streamReader.ReadToEnd();
                    if (!string.IsNullOrEmpty(copy.Trim()))
                    {
                        FileStream copyFile = File.Open(Environment.CurrentDirectory + "\" + "baseSettingClone.txt", FileMode.OpenOrCreate);
                        StreamWriter streamWriter = new StreamWriter(copyFile);
                        streamWriter.Write("
" + DateTime.Now.ToString() + "
" + copy);
                        streamWriter.Flush();
                        streamWriter.Close();
                    }
                    streamReader.Close();
                    File.Delete(_path);
                }

                FileStream fileStream = File.Create(_path);
                StreamWriter streamWriterNew = new StreamWriter(fileStream);
                streamWriterNew.Write("<root></root>");
                streamWriterNew.Flush();
                streamWriterNew.Close();
                xmlDoc.Load(_path);

            }
            return xmlDoc;
        }

        public static ProgramSettings GetInstance()
        {
            if (_programSettings == null)
            {
                _programSettings = new ProgramSettings();
            }
            return _programSettings;
        }

        public SettingsEntity ReadSettings(SettingsEntity entity)
        {
            if (entity != null)
            {
                Type entityType = entity.GetType();
                System.Reflection.PropertyInfo[] properties = entityType.GetProperties();
                XmlDocument xmlDoc = ReadXmlData(_path);
                if (xmlDoc.DocumentElement != null)
                {
                    XmlNode firstChild = xmlDoc.DocumentElement.SelectSingleNode(entity.SettingsName);
                    if (firstChild != null)
                    {
                        foreach (XmlNode node in firstChild.ChildNodes)
                        {
                            System.Reflection.PropertyInfo property = entityType.GetProperty(node.Name);
                            if (property != null && property.GetCustomAttributes(typeof(DontFill), false).Length < 1)
                            {
                                SetPropertyValue(entity, property, node.InnerText);
                            }
                        }
                    }
                }
            }
            return entity;
        }

        private void SetPropertyValue(object entity, PropertyInfo property, object value)
        {
            switch (property.PropertyType.ToString())
            {
                case "System.Int32":
                    property.SetValue(entity, Convert.ToInt32(value), null);
                    break;
                case "System.Boolean":
                    property.SetValue(entity, Convert.ToBoolean(value), null);
                    break;
                case "System.DateTime":
                    property.SetValue(entity, Convert.ToDateTime(value), null);
                    break;
                case "System.Decimal":
                    property.SetValue(entity, Convert.ToDecimal(value), null);
                    break;
                case "System.Double":
                    property.SetValue(entity, Convert.ToDouble(value), null);
                    break;
                case "System.Int64":
                    property.SetValue(entity, Convert.ToInt64(value), null);
                    break;
                default:
                    property.SetValue(entity, value, null);
                    break;
            }
        }

        public void SaveSettings(SettingsEntity entity)
        {
            if (entity != null)
            {
                Type entityType = entity.GetType();
                PropertyInfo[] properties = entityType.GetProperties();
                XmlDocument xmlDoc = ReadXmlData(_path);

                XmlNode nodeEntity = xmlDoc.DocumentElement.SelectSingleNode(entity.SettingsName);

                if (nodeEntity != null)
                {
                    foreach (System.Reflection.PropertyInfo property in properties)
                    {
                        if (property.GetCustomAttributes(typeof(DontFill), false).Length < 1)
                        {
                            foreach (XmlNode cnode in nodeEntity.ChildNodes)
                            {
                                if (property.Name.Equals(cnode.Name))
                                {
                                    cnode.InnerText = property.GetValue(entity, null).ToString();
                                    break;
                                }
                            }
                        }
                    }
                }
                else
                {
                    XmlNode node = xmlDoc.CreateNode(XmlNodeType.Element, entity.SettingsName, null);

                    foreach (System.Reflection.PropertyInfo property in properties)
                    {
                        if (property.GetCustomAttributes(typeof(DontFill), false).Length < 1)
                        {
                            XmlNode element = xmlDoc.CreateNode(XmlNodeType.Element, property.Name, null);
                            element.InnerText = property.GetValue(entity, null).ToString();
                            node.AppendChild(element);
                        }
                    }
                    xmlDoc.DocumentElement.AppendChild(node);
                }
                xmlDoc.Save(_path);
            }
        }
    }

    /// <summary>
    /// 用来限定属性是否需要保存到配置文件中
    /// </summary>
    public class DontFill : Attribute
    {

    }

    public interface SettingsEntity
    {
        string SettingsName{get;set;}
    }

    public class MonitorSettingsEntity : SettingsEntity
    {
        private string _settingsName = "MonitorSettings";
        
        [DontFill]
        public string SettingsName
        {
            get { return _settingsName; }
            set { this._settingsName = value; }
        }

        string _monitorFilePath = string.Empty;
        public string MonitorFilePath
        {
            get { return _monitorFilePath; }
            set { _monitorFilePath = value; }
        }
        int _maxThread = 5;
        public int MaxThread
        {
            get { return _maxThread; }
            set { _maxThread = value; }
        }

        long _monitorInterval = 1000000;

        public long MonitorInterval
        {
            get { return _monitorInterval; }
            set { _monitorInterval = value; }
        }

        long _infoBarMaxLines = 100;

        public long InfoBarMaxLines
        {
            get { return _infoBarMaxLines; }
            set { _infoBarMaxLines = value; }
        }
    }

    
}