xml处理类

 

using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Web;
using System.Xml;
using System.Xml.Linq;


namespace Moosoft.OA.Public
{
    /// <summary>
    /// XML操作类
    /// </summary>
    /// <remarks>XML操作类</remarks>
    public class XMLControl
    {
        #region 私有变量
        /// <summary>
        /// 文件路径
        /// </summary>
        private string xmlFilePath;
        /// <summary>
        /// 文件路径类型
        /// </summary>
        private enumXmlPathType xmlFilePathType;
        /// <summary>
        /// 实例化一个XmlDocument对象
        /// </summary>
        private XmlDocument xmlDoc = new XmlDocument();
        #endregion

        #region 私有函数
        /// <summary>
        /// 创建xml文件
        /// </summary>
        /// <param name="xmlName">文件路径</param>
        /// <returns></returns>
        private bool CreateXML(string xmlName)
        {
            try
            {
                XmlTextWriter xmltx=null;
                if (string.IsNullOrEmpty(xmlName))
                {
                    xmltx = new XmlTextWriter(HttpContext.Current.Server.MapPath(xmlName), Encoding.UTF8);
                }
                else
                {
                    xmltx = new XmlTextWriter(xmlName, Encoding.UTF8);
                }
                xmltx.WriteStartDocument();
                xmltx.WriteStartElement("ItDeer");
                xmltx.WriteEndElement();
                xmltx.WriteEndDocument();
                xmltx.Close();                
                return true;
            }
            catch { return false; }
        }

        /// <summary>
        /// 创建xml文件
        /// </summary>
        /// <param name="xmlName">文件路径</param>
        /// <param name="RootName">根名称</param>
        /// <returns></returns>
        private bool CreateXML(string xmlName, XElement RootName)
        {
            //try
            //{
                XmlTextWriter xmltx = null;
                if (string.IsNullOrEmpty(xmlName))
                {
                    xmltx = new XmlTextWriter(HttpContext.Current.Server.MapPath(xmlName), Encoding.UTF8);
                }
                else
                {
                    xmltx = new XmlTextWriter(xmlName, Encoding.UTF8);
                }
                xmltx.WriteStartDocument();
                xmltx.WriteStartElement(RootName.Name.ToString());
                foreach (XAttribute xa in RootName.Attributes())
                {
                    xmltx.WriteAttributeString(xa.Name.ToString(), xa.Value);
                }

                xmltx.WriteEndElement();
                xmltx.WriteEndDocument();
                xmltx.Close();
                SaveXmlDocument();
                return true;
            //}
            //catch { return false; }
        }

        /// <summary>
        /// 获取XmlDocument实例化对象
        /// </summary>
        /// <returns>指定的XML描述文件的路径</returns>
        private XmlDocument GetXmlDocument()
        {
            XmlDocument doc = null;

            if (this.xmlFilePathType == enumXmlPathType.AbsolutePath)
            {
                doc = GetXmlDocumentFromFile(xmlFilePath);
            }
            else if (this.xmlFilePathType == enumXmlPathType.VirtualPath)
            {
                doc = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath));
            }
            return doc;
        }
        /// <summary>
        /// 获取文件XML路径
        /// </summary>
        /// <param name="tempXmlFilePath"></param>
        /// <returns></returns>
        private XmlDocument GetXmlDocumentFromFile(string tempXmlFilePath)
        {
            try
            {
                string xmlFileFullPath = tempXmlFilePath;
                xmlDoc.Load(xmlFileFullPath);
                return xmlDoc;
            }
            catch
            {
                if (CreateXML(tempXmlFilePath))
                {
                    return GetXmlDocumentFromFile(tempXmlFilePath);
                }
                else
                {
                    return null;
                }
            }
        }
        /// <summary>
        /// 获取根节点路径
        /// </summary>
        /// <returns></returns>
        private string GetPath()
        {
            string root = xmlDoc.DocumentElement.Name;
            string result = root + "[last()]";
            return result;
        }
        #endregion

        #region 共有属性及枚举、方法
        /// <summary>
        /// 获取根节点路径
        /// </summary>
        public string Path
        {
            get { return GetPath(); }
        }
        /// <summary>
        /// 获取根节点名称
        /// </summary>
        public string RootName
        {
            get { return xmlDoc.DocumentElement.Name; }
        }
        /// <summary>
        /// 获取根节点
        /// </summary>
        public XmlNode Root
        {
            get { return xmlDoc.DocumentElement; }
        }
        /// <summary>
        /// 枚举，XML文件的路径
        /// </summary>
        /// <remarks>枚举，XML文件的路径</remarks>
        public enum enumXmlPathType
        {
            /// <summary>
            /// 相对路径
            /// </summary>
            AbsolutePath,
            /// <summary>
            /// 虚拟路径
            /// </summary>
            VirtualPath
        }
        /// <summary>
        /// 设置XML文件路径属性
        /// </summary>
        public string XmlFilePath
        {
            set
            {
                xmlFilePath = value;
            }
        }
        /// <summary>
        /// 设置文件路径类型
        /// </summary>
        public enumXmlPathType XmlFilePathTyp
        {
            set
            {
                xmlFilePathType = value;
            }
        }
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="tempXmlFilePath">XML文件相对路径</param>
        public XMLControl(string tempXmlFilePath)
        {
            this.xmlFilePathType = enumXmlPathType.VirtualPath;
            this.xmlFilePath = tempXmlFilePath;
            GetXmlDocument();
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="tempXmlFilePath">XML文件路径</param>
        /// <param name="tempXmlFilePathType">文件路径类型</param>
        public XMLControl(string tempXmlFilePath, enumXmlPathType tempXmlFilePathType)
        {
            this.xmlFilePathType = tempXmlFilePathType;
            this.xmlFilePath = tempXmlFilePath;
            GetXmlDocument();
        }
        #endregion

        /// <param name="tempXmlFilePath">XML文件路径</param>
        /// <param name="Root">跟节点名称</param>
        /// <param name="tempXmlFilePathType">文件路径类型</param>
        public XMLControl(string tempXmlFilePath, XElement Root, Moosoft.OA.Public.XMLControl.enumXmlPathType tempXmlFilePathType)
        {
            this.xmlFilePathType = tempXmlFilePathType;
            this.xmlFilePath = tempXmlFilePath;
            if (!File.Exists(xmlFilePath))
            {
                FileSystemObject.Create(xmlFilePath, FsoMethod.File);
                System.Threading.Thread.Sleep(1000);
                CreateXML(xmlFilePath, Root);
            }
            GetXmlDocument();
        }

        #region 读取指定节点的指定属性值
        /// <summary>
        /// 获取节点属性
        /// </summary>
        public List<XAttribute> GetXmlNodeAttribute(string XPath)
        {
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            List<XAttribute> attList = new List<XAttribute>();
            for (int i = 0; i < ndlist.Count; i++)
            {
                XmlAttributeCollection xmlAttr = ndlist[i].Attributes;
                for (int n = 0; n < xmlAttr.Count; n++)
                { 
                    attList.Add(new XAttribute(xmlAttr[n].Name,xmlAttr[n].Value));
                }
            }
            return attList;
        }

        
        #endregion

        #region 设置节点的属性值
        /// <summary>
        /// 设置一个指定节点的指定属性的值
        /// </summary>
        /// <param name="XPath">节点路径</param>
        /// <param name="attribute">属性名称</param>
        /// <returns></returns>
        public bool SetXmlNodeAttribute(string XPath, XAttribute attribute)
        {
            //获取节点列表
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            try
            {
                for (int i = 0; i < ndlist.Count; i++)
                {
                    XmlAttributeCollection xmlAttr = ndlist[i].Attributes;
                    bool flag = false; ;
                    for (int m = 0; m < xmlAttr.Count; m++)
                    {
                        if (xmlAttr[m].Name == attribute.Name.ToString())
                        {
                            xmlAttr.Item(m).Value = attribute.Value;
                            flag = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                       return AddAttribute(XPath, attribute);
                    }
                }
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 设置一个指定节点的指定属性的值
        /// </summary>
        /// <param name="XPath">节点路径</param>
        /// <param name="attribute">属性名称</param>
        /// <returns></returns>
        public bool SetXmlNodeAttribute(string XPath, List<XAttribute> attribute)
        {
            bool flag = true;
            for (int i = 0; i < attribute.Count; i++)
            {
               flag = SetXmlNodeAttribute(XPath, attribute[i]);
               if (!flag)
               {
                   break;
               }
            }
            return flag;
        }
        #endregion

        #region 添加属性
        /// <summary>
        /// 向指定的节点添加指定值得属性
        /// </summary>
        /// <param name="XPath">节点路径</param>
        /// <param name="attribute">添加的属性</param>
        /// <returns>bool值</returns>
        public bool AddAttribute(string XPath, List<XAttribute> attribute)
        {
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            for (int i = 0; i < ndlist.Count; i++)
            {
                XmlElement xe = (XmlElement)ndlist[i];
                foreach (XAttribute xa in attribute)
                {
                    XmlAttribute tmp = xmlDoc.CreateAttribute(xa.Name.ToString());
                    tmp.Value = xa.Value;
                    xe.Attributes.Append(tmp);
                }
            }
            return true;
        }
        /// <summary>
        /// 向指定的节点添加指定值得属性
        /// </summary>
        /// <param name="XPath">节点路径</param>
        /// <param name="attribute">添加的属性</param>
        /// <returns>bool值</returns>
        public bool AddAttribute(string XPath, XAttribute attribute)
        {
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            for (int i = 0; i < ndlist.Count; i++)
            {
                XmlElement xe = (XmlElement)ndlist[i];
                XmlAttribute tmp = xmlDoc.CreateAttribute(attribute.Name.ToString());
                tmp.Value = attribute.Value;
                xe.Attributes.Append(tmp);
            }
            return true;
        }
        #endregion

        #region 删除属性
        /// <summary>
        /// 删除指定节点的指定值的属性
        /// </summary>
        /// <param name="XPath">节点路径</param>
        /// <param name="attribute">属性列表</param>
        /// <returns>bool值</returns>
        public bool DeleteAttribute(string XPath, List<XAttribute> attribute)
        {
            for (int i = 0; i < attribute.Count; i++)
            {
                DeleteAttribute(XPath, attribute[i]);
            }
            return true;
        }

        /// <summary>
        /// 删除指定节点的指定值的属性
        /// </summary>
        /// <param name="XPath">节点路径</param>
        /// <param name="attribute">属性列表</param>
        /// <returns>bool值</returns>
        public bool DeleteAttribute(string XPath, XAttribute attribute)
        {
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            for (int i = 0; i < ndlist.Count; i++)
            {
                XmlElement xe = (XmlElement)ndlist[i];
                if (xe.Attributes[attribute.Name.ToString()].Value == attribute.Value)
                {
                    xe.RemoveAttribute(attribute.Name.ToString());
                }
            }
            return true;
        }

        #endregion

        #region 获取节点值
        /// <summary>
        /// 获取节点值
        /// </summary>
        public List<XElement> GetXmlNodesValue(string XPath)
        {
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            List<XElement> elementList = new List<XElement>();
            for (int i = 0; i < ndlist.Count; i++)
            {
                XmlElement element = (XmlElement)ndlist[i];
                XmlAttributeCollection attlist = element.Attributes;
                XElement tmp = new XElement(ndlist[i].Name, ndlist[i].Value);
                for (int n = 0; n < attlist.Count; n++)
                { 
                    tmp.Add(new XAttribute(attlist[n].Name,attlist[n].Value));
                }

                if (element.HasChildNodes)
                {
                    XmlNodeList child = element.ChildNodes;
                    for (int n = 0; n < child.Count; n++)
                    {
                        XElement ss = XElement.Parse(child[n].OuterXml);
                        tmp.Add(ss);
                    }
                }
                elementList.Add(tmp);
            }
            return elementList;
        }
        #endregion

        #region 设置节点值

        /// <summary>
        /// 设置节点值
        /// </summary>
        /// <param name="index">节点序号</param>
        /// <param name="xmlNodePath">节点路径</param>
        /// <param name="xmlNodeValue">节点值</param> 
        /// <returns>bool值</returns>        
        public bool SetXmlNodeValue(int index, string xmlNodePath, string xmlNodeValue)
        {
            try
            {
                //如果没有指定Index的值，则设置一个节点的值
                if (index != -1)
                {
                    //获取父节点下所有的相同节点
                    XmlNodeList ndlist = xmlDoc.SelectNodes(xmlNodePath);
                    //获取节点列表中的一个节点
                    XmlNode xn = ndlist[index];
                    //设置一个节点值
                    xn.InnerText = xmlNodeValue;
                }
                else
                {
                    //获取节点并设置一个值
                    XmlNode xn = xmlDoc.SelectSingleNode(xmlNodePath);
                    xn.InnerText = xmlNodeValue;
                }
                return true;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 设置一个节点的值
        /// </summary>
        /// <param name="xmlNodePath">节点路径</param>
        /// <param name="xmlNodeValue">节点值</param>
        /// <returns>bool值</returns>
        public bool SetXmlNodeValue(string xmlNodePath, string xmlNodeValue)
        {
            return SetXmlNodeValue(-1, xmlNodePath, xmlNodeValue);
        }
        #endregion

        #region 添加节点
        /// <summary>
        /// 在指定父节点下插入一个指定数值、指定属性的子节点
        /// </summary>
        /// <param name="XPath">父节点路径</param>
        /// <param name="Node">节点内容</param>
        /// <returns>bool值</returns>
        public bool AddChildNode(string XPath, XElement Node)
        {
            XmlNodeList ndlist = xmlDoc.SelectNodes(XPath);
            //try
            //{
                foreach (XmlNode xn in ndlist)
                {
                    XmlNode childXmlNode = xmlDoc.CreateElement(Node.Name.ToString());
                    if (!string.IsNullOrEmpty(Node.Value))
                    {
                        childXmlNode.Value = Node.Value;
                    }
                    if (XPath == "/")
                    {
                        xmlDoc.DocumentElement.AppendChild(childXmlNode);
                    }
                    else
                    {
                        xn.AppendChild(childXmlNode);
                    }
                    IEnumerable<XAttribute> NodeAttribute = Node.Attributes();
                    foreach (XAttribute att in NodeAttribute)
                    {
                        XmlElement ele = (XmlElement)childXmlNode;
                        ele.SetAttribute(att.Name.ToString(), att.Value);
                    }
                }
                return true;
            //}
            //catch
            //{
            //    return false;
            //}
        }

         /// <summary>
        /// 在指定父节点下插入一个指定数值、指定属性的子节点
        /// </summary>
        /// <param name="XPath">父节点路径</param>
        /// <param name="Node">节点内容</param>
        /// <returns>bool值</returns>
        public bool AddChildNode(string XPath, List<XElement> Node)
        {
            bool flag = true;
            for (int i = 0; i < Node.Count; i++)
            {
                flag = AddChildNode(XPath, Node);
                if (!flag)
                {
                    break;
                }
            }
            return flag;
        }
        #endregion

        #region 删除节点

        /// <summary>
        /// 删除指定一个的节点及其下面的子节点
        /// </summary>
        /// <param name="NodeIndex">节点索引</param>
        /// <param name="NodePath">节点路径</param>
        /// <returns>bool值</returns>
        public bool DeleteNode(int NodeIndex, string NodePath)
        {
            try
            {
                //是否有多行，并指定删除哪一行
                if (NodeIndex != -1)
                {
                    //获取节点列表
                    XmlNodeList ndlist = xmlDoc.SelectNodes(NodePath);
                    //获取要删除的节点
                    XmlNode xn = (XmlNode)ndlist[NodeIndex];
                    //删除节点
                    xn.ParentNode.RemoveChild(xn);
                }
                else
                {
                    //获取节点列表
                    XmlNodeList ndlist = xmlDoc.SelectNodes(NodePath);
                    //删除列表
                    foreach (XmlNode xn in ndlist)
                    {
                        xn.ParentNode.RemoveChild(xn);
                    }
                }
            }
            catch { return false; }
            return true;
        }
        /// <summary>
        /// 删除节点及节点下的子节点
        /// </summary>
        /// <param name="NodePath">节点路径</param>
        /// <returns>bool值</returns>
        public bool DeleteNode(string NodePath)
        {
            return DeleteNode(-1, NodePath);
        }
        #endregion

        #region 保存XML文件
        /// <summary>
        /// 保存文件
        /// </summary>
        public void SaveXmlDocument()
        {
            try
            {
                //保存设置的结果
                xmlDoc.Save(HttpContext.Current.Server.MapPath(xmlFilePath));
            }
            catch
            {
                try { xmlDoc.Save(xmlFilePath); }
                catch (XmlException xmle)
                {
                    throw xmle;
                }
            }
        }
        /// <summary>
        /// 保存文件
        /// </summary>
        /// <param name="tempXMLFilePath">文件路径</param>
        public void SaveXmlDocument(string tempXMLFilePath)
        {
            try
            {
                //保存设置的结果
                xmlDoc.Save(tempXMLFilePath);
            }
            catch (XmlException xmle)
            {
                throw xmle;
            }
        }
        #endregion
    }
}