以前写的一个XML文件的助手类，现在看起来觉得有的地方不好而难用，不过我觉得还是有些启发吧(C#,XML)

/* Filename:XMLHelper.cs
 * Writer:dou7
 * Create Date:2010-12-25
 * ========Update Message===========
 * by:           date:
 * by:           date:
 * by:           date:
 */

 

using System;
using System.IO;
using System.Data;
using System.Collections;
using System.Xml;
using dou7.Common;

namespace dou7.XML
{
    public class XMLHelper
    {
        private string _SourceFile = "";
        public string SourceFile
        {
            get
            {
                return _SourceFile;
            }
            set
            {
                Load(value);
            }
        }

        public XmlDocument Doc;

        /// <summary>
        /// 获取或设置当前节点
        /// </summary>
        public string CurrentNodeName
        {
            get
            {
                return GetNodeFullName(CurrentNode);
            }
            set
            {
                value = value.TrimEnd('/');
                CurrentNode = GetNode(value);
                CurrentElement = (XmlElement)CurrentNode;
            }
        }

        /// <summary>
        /// 根节点
        /// </summary>
        public XmlNode RootNode
        {
            get
            {
                XmlNode rootNode = Doc.SelectSingleNode(Doc.LastChild.Name);
                return rootNode;
            }
        }

        /// <summary>
        /// 获取节点的全名
        /// </summary>
        /// <param name="node">节点</param>
        /// <returns></returns>
        public string GetNodeFullName(XmlNode node)
        {
            string nodeFullName = GetNodeFullPath(node);
            return nodeFullName.Substring("/#document/".Length);
        }

        private string GetNodeFullPath(XmlNode node)
        {
            if (node == null)
            {
                return "";
            }
            else
            {
                return GetNodeFullPath(node.ParentNode) + "/" + node.Name;
            }
        }

        private XmlNode _CurrentNode = null;
        public XmlNode CurrentNode
        {
            get
            {
                if ( _CurrentNode == null)
                {
                    _CurrentNode = Doc.LastChild;
                }
                return _CurrentNode;
            }
            set
            {
                _CurrentNode = value;
                _CurrentElement = (XmlElement)_CurrentNode;
            }
        }

        private XmlElement _CurrentElement = null;
        private XmlElement CurrentElement
        {
            get
            {
                if (_CurrentElement == null)
                {
                    _CurrentElement = (XmlElement)Doc.LastChild;
                }
                return _CurrentElement;
            }
            set
            {
                _CurrentElement = value;
                CurrentNode = (XmlNode)_CurrentElement;
            }
        }

        /// <summary>
        /// 获取当前节点属性列表
        /// </summary>
        public DList2 Attributes
        {
            get
            {
                DList2 list = new DList2();
                foreach (XmlAttribute xa in CurrentNode.Attributes)
                {
                    list[xa.Name] = xa.InnerText;
                }
                return list;
            }
        }

        public XMLHelper this[string nodeName]
        {
            get
            {
                CurrentNodeName = nodeName;
                return this;
            }
        }

        /// <summary>
        ///  获取或设置当前节点名称
        /// </summary>
        public string Name
        {
            get
            {
                 return CurrentNode.Name;
            }
            set
            {
               XmlElement elem = Doc.CreateElement(value);
               elem.InnerText =  CurrentNode.InnerText;
               XmlNode node = CurrentNode;
               CurrentNode = CurrentNode.ParentNode;
               CurrentNode = CurrentNode.ReplaceChild((XmlNode)elem, node);
               this.Save();
            }

        }

        /// <summary>
        /// 获取或设置当前节点内容
        /// </summary>
        public string Value
        {
            get
            {
                 return CurrentNode.InnerText;
            }
            set
            {
                CurrentNode.InnerText = value;
                this.Save();
            }
        }

        /// <summary>
        /// 下一节点
        /// </summary>
        public XmlNode UpNode
        {
            get
            {
                if (this.CurrentNode != null)
                {
                    return this.CurrentNode.PreviousSibling;
                }
                return null;
            }
        }

        /// <summary>
        /// 上一节点
        /// </summary>
        public XmlNode NextNode
        {
            get
            {
                if (this.CurrentNode != null)
                {
                    return this.CurrentNode.NextSibling;
                }
                return null;
            }
        }

        /// <summary>
        /// 当前节点子节点列表结构数据
        /// </summary>
        public DataTable ListTable
        {
            get
            {
                if (CurrentNode != null)
                {
                    XmlNodeList xmlNodes = CurrentNode.ChildNodes;
                    if (xmlNodes.Count > 0)
                    {
                        DataTable nodelist = new DataTable();
                        nodelist.Columns.Add("NAME");
                        nodelist.Columns.Add("VALUE");
                        DataRow dr;
                        foreach (XmlNode node in xmlNodes)
                        {
                            if (node.NodeType != XmlNodeType.Element) continue;
                            dr = nodelist.NewRow();
                            dr["NAME"] = node.LocalName;
                            dr["VALUE"] = node.InnerText;
                            foreach (XmlNode attribute in node.Attributes)
                            {
                                string columnName = attribute.LocalName;
                                if (!nodelist.Columns.Contains(columnName))
                                {
                                    nodelist.Columns.Add(columnName);
                                }
                                dr[columnName] = attribute.InnerText;
                            }
                            nodelist.Rows.Add(dr);
                        }
                        return nodelist;
                    }
                }
                return null;
            }
        }

        /// <summary>
        /// 获取当前节点的子项列表[键值对]
        /// </summary>
        public DList2 List
        {
            get
            {
                DList2 nodelist = new DList2();
                if (CurrentNode != null)
                {
                    XmlNodeList xmlNodes = CurrentNode.ChildNodes;
                    if (xmlNodes.Count > 0)
                    {
                        foreach (XmlNode node in xmlNodes)
                        {
                            if (node.NodeType != XmlNodeType.Element) continue;
                            nodelist[node.LocalName] = node.InnerText;
                        }
                    }
                }
                return nodelist;
            }
        }

        /// <summary>
        /// 获取当前节点的子项列表[值表]
        /// </summary>
        public DList2 List2
        {
            get
            {
                DList2 nodelist = new DList2();
                if (CurrentNode != null)
                {
                    XmlNodeList xmlNodes = CurrentNode.ChildNodes;
                    if (xmlNodes.Count > 0)
                    {
                        foreach (XmlNode node in xmlNodes)
                        {
                            if (node.NodeType != XmlNodeType.Element) continue;
                            nodelist[nodelist.Count.ToString()] = node.InnerText;
                        }
                    }
                }
                return nodelist;
            }
        }

        public XMLHelper()
        {
            Doc = new XmlDocument();
        }
        public XMLHelper(string sourceFile):this()
        {
            SourceFile = sourceFile;
        }

        public void Create(string rootNode)
        {
            Doc = new XmlDocument();
            XmlNode xmlnode = Doc.CreateNode(XmlNodeType.XmlDeclaration, "", "");
            Doc.AppendChild(xmlnode);
            XmlElement xmlelem = Doc.CreateElement(rootNode);
            Doc.AppendChild(xmlelem);
        }
       

        /// <summary>
        /// 建立xml文件
        /// </summary>
        /// <param name="sourceFile">文件路径</param>
        /// <param name="rootNode">根节点</param>
        public void Create(string sourceFile, string rootNode)
        {
            Doc = new XmlDocument();
            XmlNode xmlnode = Doc.CreateNode(XmlNodeType.XmlDeclaration, "", "");
            Doc.AppendChild(xmlnode);
            XmlElement xmlelem = Doc.CreateElement(rootNode);
            Doc.AppendChild(xmlelem);
            Save(sourceFile);
        }

        public void Load(string sourceFile)
        {
            Doc.Load(sourceFile);
            this._SourceFile = sourceFile;
        }

        /// <summary>
        /// 查找节点
        /// </summary>
        /// <param name="nodeFullName">节点path</param>
        /// <returns></returns>
        public bool ExistsNode(string nodeFullName)
        {
            XmlNode node = Doc.SelectSingleNode(nodeFullName);
            return node != null;
        }

        /// <summary>
        /// 下移一节点【不进入子节点】
        /// </summary>
        public void MoveNext()
        {
            XmlNode node = this.CurrentElement.NextSibling;
            if (node != null)
            {
                this.CurrentNode = node;
            }
        }

        /// <summary>
        /// 上移一节点【不进入子节点】
        /// </summary>
        public void MoveUp()
        {
            XmlNode node = this.CurrentElement.PreviousSibling;
            if(node != null)
            {
                this.CurrentNode = node;
            }
        }

        /// <summary>
        /// 在当前节点下新增[子节点]
        /// </summary>
        /// <param name="nodeName">子节点名</param>
        /// <param name="innerText">内容</param>
        /// <returns>新增的子元素</returns>
        public XmlElement AddNode(string nodeName, string innerText)
        {
            XmlElement elem = Doc.CreateElement(nodeName);
            elem.InnerText = innerText;
            elem = (XmlElement)this.CurrentElement.AppendChild(elem);
            this.Save();
            return elem;
        }

        /// <summary>
        /// 移除当前节点
        /// </summary>
        public void Remove()
        {
            if (CurrentNode != RootNode)
            {
                XmlNode parentNode = CurrentNode.ParentNode;
                parentNode.RemoveChild(CurrentNode);
                this.Save();
                CurrentNode = parentNode;   //当前节点上移
            }
        }

        /// <summary>
        /// 移除指定节点
        /// </summary>
        /// <param name="nodeName">指定节点</param>
        public void Remove(string nodeName)
        {
            XmlNode removeNode = Doc.SelectSingleNode(nodeName);
            if (removeNode != null && removeNode != RootNode)
            {
                if (removeNode == CurrentNode)
                {
                    CurrentNode = CurrentNode.ParentNode;    //如果移除的是当前节点，则当前节点上移
                }
                removeNode.ParentNode.RemoveChild(removeNode);
                this.Save();
            }    
        }

        /// <summary>
        /// 移除指定节点下的指定子节点
        /// </summary>
        /// <param name="startNode">指定节点</param>
        /// <param name="childIndex">指定子节点索引</param>
        public void Remove(string parentNode,int childIndex)
        {
            XmlNode child = GetNode(parentNode).ChildNodes.Item(childIndex);
            if (child != null)
            {
                if (CurrentNode == child )
                {
                    CurrentNode = CurrentNode.ParentNode;    //如果移除的是当前节点，则当前节点上移
                }
                child.ParentNode.RemoveChild(child);
                this.Save();
            }
        }

        /// <summary>
        /// 设置当前节点的属性【没有时则建立，否则修改】
        /// </summary>
        /// <param name="attributeName">属性名</param>
        /// <param name="innerText">值</param>
        public void SetAttribute(string attributeName, string innerText)
        {
            XmlAttribute attribute = this.CurrentNode.Attributes[attributeName];
            if (attribute == null)
            {
                attribute = Doc.CreateAttribute(attributeName);
            }
            attribute.InnerText = innerText;
            this.CurrentNode.Attributes.Append(attribute);
            this.Save();
        }

        /// <summary>
        /// 移除当前节点指定属性
        /// </summary>
        /// <param name="attributeName">指定属性</param>
        public void RemoveAttribute(string attributeName)
        {
            XmlAttribute attribute = this.CurrentNode.Attributes[attributeName];
            this.CurrentNode.Attributes.Remove(attribute);
            this.Save();
        }

        /// <summary>
        /// 在当前节点下插入节点
        /// </summary>
        /// <param name="attributeName">节点名</param>
        /// <param name="innerText">值</param>
        public XmlNode InsertNode(string attributeName, string innerText)
        {
            XmlElement elem =  Doc.CreateElement(attributeName);
            elem.InnerText = innerText;
            XmlNode node = CurrentNode.ParentNode.InsertAfter((XmlNode)elem, CurrentNode);
            this.Save();
            return node;
        }

        /// <summary>
        /// 插入到指定父节点下的指定位置
        /// </summary>
        /// <param name="parentNode">指定父节点</param>
        /// <param name="insertIndex">指定位置，【不存在则插在最后】</param>
        /// <param name="attributeName">节点名</param>
        /// <param name="innerText">内容</param>
        public XmlNode InsertNode(string parentNode, int insertIndex, string attributeName, string innerText)
        {
            XmlElement elem =  Doc.CreateElement(attributeName);
            elem.InnerText = innerText;
            XmlNode parentnode = GetNode(parentNode);
            insertIndex = insertIndex <= 0 ? 0 : insertIndex - 1;
            XmlNode child = parentnode.ChildNodes.Item(insertIndex);
            XmlNode node;
            if (child != null)
            {
                if (insertIndex == 0)
                {
                    node = parentnode.InsertBefore(elem, child);
                }
                else
                {
                    node = parentnode.InsertAfter(elem, child);
                }
            }
            else
            {
                node = parentnode.AppendChild(elem);
            }
            this.Save();
            return node;
        }

        private XmlNode GetNode(string nodeName)
        {
            XmlNode node = Doc.SelectSingleNode(nodeName);
            if (node == null)
            {
                throw new Exception("并不包含指定节点!");
            }
            return node ;
        }

        /// <summary>
        /// 获取指定父节点下DList2结构数据
        /// </summary>
        /// <param name="parentNode"></param>
        /// <returns></returns>
        public DList2 GetList(string parentNode)
        {
            DList2 d2 = new DList2();
            XmlNode currNode = GetNode(parentNode);
            foreach (XmlNode node in currNode.ChildNodes)
            {
                d2[node.Name] = node.InnerText;
            }
            return d2;
        }

        /// <summary>
        /// 获取指定父节点下表结构数据
        /// </summary>
        /// <param name="parentNode">数据区开始</param>
        /// <param name="fieldList">要获取的字段名称</param>
        /// <returns></returns>
        public DataTable GetData(string parentNode, params string[] fieldList)
        {
            XmlNode currNode = GetNode(parentNode);
            XmlNodeList rows = currNode.ChildNodes;
            DataTable dt = new DataTable();
            foreach (string field in fieldList)
            {
                dt.Columns.Add(field);
            }

            DataRow dr;
            foreach (XmlNode row in rows)
            {
                dr = dt.NewRow();
                XmlNodeList fields = row.ChildNodes;
                bool isNull = false;
                foreach (XmlNode field in fields)
                {
                    if (field.NodeType != XmlNodeType.Element) { isNull = true; continue; }
                    if (fieldList.Length > 0)
                    {
                        if (dt.Columns.Contains(field.Name))
                        {
                            dr[field.Name] = field.InnerText.Trim();
                            isNull = field.InnerText.Trim() == "";
                        }
                    }
                    else
                    {
                        if (!dt.Columns.Contains(field.Name))
                        {
                            dt.Columns.Add(field.Name);
                        }
                        dr[field.Name] = field.InnerText.Trim();
                        isNull = field.InnerText.Trim() == "";
                    }
                   
                }
                if (!isNull)
                {
                    dt.Rows.Add(dr);
                }
            }
            return dt;
        }

        /// <summary>
        /// 将DataTable中的数据导入Xml【格式：<DataRow>数据<DataRow><DataRow>数据<DataRow>……】
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="parentNode">parentNode父节点</param>
        /// <param name="fieldList">可选导入的字段</param>
        public void ImportData(DataTable dt, string parentNode,params string [] fieldList)
        {
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                this.CurrentNodeName = parentNode;
                this.CurrentElement = this.AddNode("DataRow", "");
                if (fieldList.Length > 0)
                {
                    foreach (string field in fieldList)
                    {
                        this.AddNode(field, dt.Rows[i][field].ToString());
                    }
                }
                else
                {
                    for (int x = 0; x < dt.Columns.Count;x ++ )
                    {
                        this.AddNode(dt.Columns[x].ColumnName, dt.Rows[i][dt.Columns[x].ColumnName].ToString());
                    }
                }
            }
            this.CurrentNodeName = parentNode;
        }

        /// <summary>
        /// 将键值列表数据导入Xml文件
        /// </summary>
        /// <param name="list">list</param>
        /// <param name="parentNode">parentNode父节点</param>
        /// <param name="fieldList">可选导入的字段</param>
        /// <returns></returns>
        public XmlNode ImportData(IDictionary list, string parentNode, params string[] fieldList)
        {
            return ImportData(list, parentNode, true , fieldList);
        }

        /// <summary>
        /// 将键值列表数据导入Xml文件
        /// </summary>
        /// <param name="list">list</param>
        /// <param name="parentNode">parentNode父节点</param>
        /// <param name="isPositive">是否正序</param>
        /// <param name="fieldList">可选导入的字段</param>
        /// <returns>当前行的节点</returns>
        public XmlNode ImportData(IDictionary list, string parentNode, bool isPositive , params string[] fieldList)
        {
            this.CurrentNodeName = parentNode;
            if (isPositive)
            {
                this.CurrentElement = this.AddNode("DataRow", "");
            }
            else
            {
                this.CurrentNode = this.InsertNode(parentNode, 0, "DataRow", "");
            }

            if (fieldList.Length > 0)
            {
                foreach(string key in  fieldList)
                {
                    if (list.Contains(key))
                    {
                        this.AddNode(key, list[key].ToString());
                    }
                }
            }
            else
            {
                foreach (string key in list.Keys)
                {
                    this.AddNode(key, list[key].ToString());
                }
            }
            XmlNode lastNode = (XmlNode)CurrentElement;
            this.CurrentNodeName = parentNode;
            return lastNode;
        }

        /// <summary>
        /// 保存文件
        /// </summary>
        public void Save()
        {
            if (_SourceFile != "")
            {
                Doc.Save(this._SourceFile);
            }
        }

        /// <summary>
        /// 另存文件
        /// </summary>
        /// <param name="filePath">文件路径</param>
        public void Save(string filePath)
        {
            Doc.Save(filePath);
            this._SourceFile = filePath;
        }

    }
}