[转]简单XML文件C#操作方法

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml;
using System.Xml.XPath;

namespace LuckerSoft
{
    /// <summary>
    /// 该XML文件操作类提供一系统自动完成的操作类.包括常用的数据读取,写入与删除.
    /// 支持非字符型数据(即所有支持序列化的object类型)的操作.
    /// 并具有文件或结点不存在时自动创建的功能.
    /// 该类采用静态类设计,用类名直接调用其公有方法,主要适用于对XML文件中单个结点的操作
    /// 作者:Lucker
    /// 日期:2009年12月29日
    /// 版本:1.0.0
    /// </summary>
    public static class MyXML
    {
        /// <summary>
        /// 从指定的XML文件中读取指定路径下所有结点的值
        /// </summary>
        /// <param name="XMLFile">带路径的XML文件名</param>
        /// <param name="Path">带路径的结点名</param>
        /// <returns></returns>
        public static string[] ReadNodes(string XMLFile, string Path)
        {
            string Values="";            
            XmlDocument xmldoc = CheckFileExit(XMLFile);
            XmlNode Node = FindNode(xmldoc, Path);
            foreach (XmlNode node in Node.ChildNodes)
            {
                Values += node.Name.ToString() + ",";
            }
            return Values.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
        }
        
        /// <summary>
        /// 从指定的XML文件中读取指定路径下单个结点的值.当结点不存在时,根据所提供默认值自动创建.
        /// </summary>
        /// <param name="XMLFile"></param>
        /// <param name="Path"></param>
        /// <param name="DefaultValue">结点不存在时,提供的默认值</param>
        /// <returns></returns>
        public static string ReadNode(string XMLFile, string Path, string DefaultValue)
        {
            XmlDocument xmldoc = CheckFileExit(XMLFile);
            XmlNode Node = FindNode(xmldoc, Path);
            if (Node != null)
            {
                return Node.InnerText;
            }
            else
            {
                WriteNode(XMLFile, Path, DefaultValue);
                return DefaultValue;
            }
        }

        /// <summary>
        /// 读取一个object类型的结点数据.
        /// </summary>
        /// <param name="XMLFile"></param>
        /// <param name="Path"></param>
        /// <param name="DefaultValue">object类型的数据实际上是经过序列化后转换成string保存在文件中的</param>
        /// <returns></returns>
        public static object ReadNode(string XMLFile, string Path, object DefaultValue)
        {
            //读出文件中的string值
            string Value=ReadNode(XMLFile, Path, Object2String(DefaultValue));
            //再将读取出来的string数据需要转化成object对象.
            object o= String2Object(Value);
            return o;
        }
        
        /// <summary>
        /// 向指定的XML文件中写入指定路径的结点数据.当指定结点不存在是时,将沿路径依次创建各父结点
        /// </summary>
        /// <param name="XMLFile"></param>
        /// <param name="Path"></param>
        /// <param name="Value">结点值</param>
        public static void WriteNode(string XMLFile, string Path, string Value)
        {
            XmlDocument myDoc = CheckFileExit(XMLFile);
            PathNode = null;
            PathDepth = 0;
            ParentNode = null;
            CheckPath(myDoc, Path);
            XmlNode Node = FindNode(myDoc, Path);
            if (Node != null)
            {
                UpdateXmlNode(Value, Node);
            }
            myDoc.Save(XMLFile);
        }
        
        /// <summary>
        /// 写入一个object类型的对象.
        /// </summary>
        /// <param name="XMLFile"></param>
        /// <param name="Path"></param>
        /// <param name="Value"></param>
        public static void WriteNode(string XMLFile, string Path, object Value)
        {
            //经序列化后转换成string型后再写入.
            WriteNode(XMLFile, Path, Object2String(Value));
        }

        /// <summary>
        /// 删除指定的结点
        /// </summary>
        /// <param name="XMLFile"></param>
        /// <param name="Path"></param>
        /// <returns></returns>
        public static bool DeleteNode(string XMLFile, string Path)
        {
            XmlDocument myDoc = CheckFileExit(XMLFile);
            XmlNode Node = FindNode(myDoc, Path);
            if(Node!=null)
            {
                if (Node.ParentNode != null)
                {
                    Node.ParentNode.RemoveChild(Node);
                }
                else
                {
                    myDoc.RemoveChild(Node);
                }
                myDoc.Save(XMLFile);
            }
            return true;
        }
        
        #region 私有方法

        /// <summary>
        /// 更新指定结点的值
        /// </summary>
        /// <param name="TextName">结点的值</param>
        /// <param name="XNe">要更新的结点</param>
        /// <returns></returns>
        private static bool UpdateXmlNode(string TextName, XmlNode XNe)
        {
            if (XNe != null)
            {
                XNe.InnerText = TextName;
                return true;
            }
            else
                return false;
        }
        
        /// <summary>
        /// 插入一个指定的XML元素
        /// </summary>
        /// <param name="myDoc"></param>
        /// <param name="ElementName">元素名</param>
        /// <param name="Text">元素值</param>
        /// <returns></returns>
        private static XmlNode InsertXmlElement(XmlDocument myDoc, string ElementName, string Text)
        {
            if (ElementName != "")
            {
                XmlElement XEt = myDoc.CreateElement("",ElementName,"");
                XEt.InnerText = Text;
                return (XmlNode)XEt;
            }
            else
            {
                return null;
            }
        }
        
        static string[] PathNode = null;
        static int PathDepth=0;
        static XmlNode ParentNode;
        /// <summary>
        /// 获取路径结点集指定深度的路径表示
        /// </summary>
        /// <param name="depth"></param>
        /// <returns></returns>
        private static string GetPath(int depth)
        {
            string path = "";
            for (int i = 0; i < depth && i < PathNode.Length; i++)
            {
                path += PathNode[i] + "/";
            }
            return path.Substring(0,path.Length - 1);
        }
        
        /// <summary>
        /// 递归检查指定路径上的结点是否存在,不存在则创建
        /// </summary>
        /// <param name="myDoc"></param>
        /// <param name="Path"></param>
        private static void CheckPath(XmlDocument myDoc, string Path)
        {
            if (PathNode == null)
            {
                PathNode = Path.Split(new char[] { '/' });
                PathDepth = 0;
            }
            if (PathDepth < PathNode.Length)
            {
                string NewPath = GetPath(++PathDepth);
                string Name = PathNode[PathDepth-1];
                XmlNode Node = FindNode(myDoc, NewPath);
                if (Node == null)
                {
                    XmlNode NewNode = InsertXmlElement(myDoc, Name, null);
                    ParentNode.AppendChild(NewNode);
                    ParentNode = FindNode(myDoc, NewPath);
                }
                else
                {
                    ParentNode = Node;
                }
                CheckPath(myDoc, NewPath);
            }
        }
        
        /// <summary>
        /// 查询指定路径上的第一个结点
        /// </summary>
        /// <param name="myDoc"></param>
        /// <param name="Path"></param>
        /// <returns></returns>
        private static XmlNode FindNode(XmlDocument myDoc, string Path)
        {
            //Path:aaaa/bbbb/cccc
            XmlNode myNode = myDoc.SelectSingleNode(Path);
            if (!(myNode == null))
            {
                return myNode;
            }
            return null;
        }
        
        /// <summary>
        /// 查询指定路径上的所有结点
        /// </summary>
        /// <param name="myDoc"></param>
        /// <param name="Path"></param>
        /// <returns></returns>
        private static XmlNodeList FindNodes(XmlDocument myDoc, string Path)
        {
            //Path:aaaa/bbbb/cccc
            XmlNodeList myNodeList = myDoc.SelectNodes(Path);
            if (!(myNodeList == null))
            {
                return myNodeList;
            }
            return null;
        }
        
        /// <summary>
        /// 查询指定的XML文件是否存在.如果不存在,则创建一个具有默认根结点的XML文件.
        /// </summary>
        /// <param name="XMLFile"></param>
        /// <returns></returns>
        private static XmlDocument CheckFileExit(string XMLFile)
        {
            XmlDocument xmldoc = new XmlDocument();
            if (File.Exists(XMLFile))
            {
                try
                {
                    xmldoc.Load(XMLFile);
                }
                catch (Exception ex)
                {
                    throw new Exception("载入XML文件[" + XMLFile + "]失败.\r\n"+ex.Message);
                }
            }
            else
            {
                XmlDeclaration xn = xmldoc.CreateXmlDeclaration("1.0", "gb2312", null);
                xmldoc.AppendChild(xn);
                XmlElement xmlelem = xmldoc.CreateElement("", "打印项目模板", "");
                xmldoc.AppendChild(xmlelem);
                xmldoc.Save(XMLFile);
            }
            return xmldoc;
        }

        ///   <summary>
        ///   序列化为二进制字节数组
        ///   </summary>
        ///   <param   name="request">要序列化的对象</param>
        ///   <returns>字节数组</returns>
        private static byte[] SerializeBinary(object request)
        {
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            System.IO.MemoryStream memStream = new System.IO.MemoryStream();
            serializer.Serialize(memStream, request);
            return memStream.GetBuffer();
        }

        ///   <summary>
        ///   从二进制数组反序列化得到对象
        ///   </summary>
        ///   <param   name="buf">字节数组</param>
        ///   <returns>得到的对象</returns>
        private static object DeserializeBinary(byte[] buf)
        {
            System.IO.MemoryStream memStream = new MemoryStream(buf);
            memStream.Position = 0;
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =
                new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            object newobj = deserializer.Deserialize(memStream);
            memStream.Close();
            return newobj;
        }
        
        private static string Object2String(object Obj)
        {
            StringBuilder sb = new StringBuilder();
            byte[] ByteObject = SerializeBinary(Obj);
            foreach (byte b in ByteObject)
            {
                sb.Append(((int)b).ToString());
                sb.Append(",");
            }
            return sb.Remove(sb.Length-1,1).ToString();
        }
        
        private static object String2Object(string Value)
        {
            string[] V = Value.Split(new char[] { ',' },StringSplitOptions.RemoveEmptyEntries);
            byte[] ByteObject = new byte[V.Length];
            for(int i=0;i<ByteObject.Length;i++)
            {
                ByteObject[i] = Convert.ToByte(V[i]);
            }
            return DeserializeBinary(ByteObject);
        }
        
        #endregion
    }
}