Unity 读写XML文件

小编自己写了一套读写XML文件的脚本，方便后面项目中的使用。需要的同学可以自行拿去，代码如下：

/* 创建时间：2017/12/22
 * 
 * 编写：    
 * 
 * 介绍：    属于静态类,用于写入和读取XML文件.
 * 
 * 注意：    
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System.Xml;
using System.Text;
using System.Security.Cryptography;
using System;

public static class XMLManager
{
    /// <summary>
    /// 创建XML文件 (如果已存在,则不创建)
    /// </summary>
    /// <param name="path">XML文件路径</param>
    /// <param name="isEncryptFile">是否创建加密的XML文件</param>
    public static bool CreateXML(string _xmlPath, bool _isEncryptFile = false)
    {
        if (File.Exists(_xmlPath))
        {
            Debug.Log(_xmlPath + "路径下已存在对应XML文件,跳过创建.");
            return false;
        }

        int count = 0;
        for (int i = _xmlPath.Length - 1; i > 0; --i)
        {
            if (_xmlPath[i] != '/')
                ++count;
            else if (_xmlPath[i] == '/')
                break;
        }
        StringBuilder _path = new StringBuilder(_xmlPath.Length);
        for (int i = 0; i < _xmlPath.Length - count - 1; ++i)
        {
            _path.Append(_xmlPath[i]);
        }
        //Debug.Log(_path);

        if (!Directory.Exists(_path.ToString()))
            Directory.CreateDirectory(_path.ToString());

        XmlDocument doc = new XmlDocument();
        XmlElement root = doc.CreateElement("Root");
        doc.AppendChild(root);
        doc.Save(_xmlPath);

        //将创建的新XML文件加密
        if (_isEncryptFile) EncrtyptSaveXML(_xmlPath);

        Debug.Log(_xmlPath + "路径下创建XML文件成功!");
        return true;
    }

    /// <summary>
    /// 添加节点(当_parentNodeName参数为NULL时默认创建节点到根节点中)
    /// </summary>
    /// <param name="_path">XML文件路径</param>
    /// <param name="_nodeName">节点名</param>
    /// <param name="_isSameName">是否重名添加</param>
    /// <param name="_parentNodeName">父节点名</param>
    public static bool AddNode(string _xmlPath, string _nodeName, bool _isSameName, string _parentNodeName = null)
    {
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("该路径下的XML文件不存在!!");
            return false;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");  //SelectSingleNode只能查找该节点下的子节点

        //当_parentNodeName为null时添加到根节点Root中
        if (_parentNodeName == null)
        {
            XmlNodeList nodeList = root.ChildNodes;
            //重名添加
            if (_isSameName)
            {
                XmlElement node = doc.CreateElement(_nodeName);
                root.AppendChild(node);
            }
            //不重名添加
            else if (!_isSameName)
            {
                if (!IsSameName(nodeList, _nodeName))
                {
                    XmlElement node = doc.CreateElement(_nodeName);
                    root.AppendChild(node);
                }
            }
        }
        //当_parentNodeName不为null时,一直遍历直到找到_parentNodeName节点
        else if (_parentNodeName != null)
        {
            List<XmlNode> nodeList = FindNode(_parentNodeName, root);
            if (nodeList.Count == 1)
            {
                if (IsSameName(nodeList[0].ChildNodes, _nodeName))
                {
                    if (_isSameName)
                    {
                        XmlElement ele = doc.CreateElement(_nodeName);
                        nodeList[0].AppendChild(ele);
                    }
                    else if (!_isSameName)
                    {
                        Debug.Log(_parentNodeName + "节点的子节点中已存在" + _nodeName + "节点");
                        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
                        return false;
                    }
                }
                else if (!IsSameName(nodeList[0].ChildNodes, _nodeName))
                {
                    XmlElement ele = doc.CreateElement(_nodeName);
                    nodeList[0].AppendChild(ele);
                }
            }
            else if (nodeList.Count <= 0)
            {
                Debug.LogError("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
                if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
                return false;
            }
            else if (nodeList.Count > 1)
            {
                Debug.LogError("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
                if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
                return false;
            }
        }
        
        //存储xml文件
        doc.Save(_xmlPath);
        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return true;
    }

    /// <summary>
    /// 获取所有同名节点,当_parentNodeName不为空时可根据父节点下的子节点进行查找
    /// </summary>
    /// <param name="_xmlPath">XML文件路径</param>
    /// <param name="_nodeName">节点名</param>
    /// <param name="_parentNodeName">查找的节点的父节点名</param>
    /// <returns></returns>
    public static List<XmlNode> GetNodes(string _xmlPath, string _nodeName, string _parentNodeName = null)
    {
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("该路径下的XML文件不存在!!");
            return null;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");  //SelectSingleNode只能查找该节点下的子节点

        if (_parentNodeName == null)
        {
            List<XmlNode> nodeList = FindNode(_nodeName, root);
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);   //如果解密过,则重名加密一次
            return nodeList;
        }
        else if (_parentNodeName != null)
        {
            List<XmlNode> nodeList = FindNode(_nodeName, root);
            if (nodeList.Count > 0)
            {
                List<XmlNode> childList = new List<XmlNode>();
                for (int i = 0; i < nodeList.Count; i++)
                {
                    if (nodeList[i].ParentNode.Name == _parentNodeName)
                    {
                        childList.Add(nodeList[i]);
                    }
                }

                if (isEncryptFile) EncrtyptSaveXML(_xmlPath);   //如果解密过,则重名加密一次
                return childList;
            }
            else if (nodeList.Count <= 0)
            {
                Debug.LogError("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
                if (isEncryptFile) EncrtyptSaveXML(_xmlPath);   //如果解密过,则重名加密一次
                return null;
            }
        }

        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);   //如果解密过,则重名加密一次
        return null;
    }

    /// <summary>
    /// 给指定节点添加属性 (如有重名的属性名,则不添加)
    /// </summary>
    /// <param name="_xmlPath">XML文件路径</param>
    /// <param name="_nodeName">节点名</param>
    /// <param name="_attributeName">属性名</param>
    /// <param name="_value">属性值</param>
    public static bool AddAttribute(string _xmlPath, string _nodeName, string _attributeName, string _value)
    {
        //判断该路径下XML是否存在
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("添加属性失败,该路径下的文件不存在！");
            return false;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");
        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }
        else if (nodeList.Count == 1)
        {
            //这里系统做了处理,如果添加的属性名是重名的,则不会添加
            XmlAttribute attribute = doc.CreateAttribute(_attributeName);
            attribute.Value = _value;
            XmlElement ele = (XmlElement)nodeList[0];
            ele.SetAttributeNode(attribute);
        }
        else if (nodeList.Count > 1)
        {
            Debug.LogError("在" + _xmlPath + "文件中的找到与" + _nodeName + "相同的多个节点,跳过添加!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;

            ////这里系统做了处理,如果添加的属性名是重名的,则不会添加
            //for (int i = 0; i < nodeList.Count; i++)
            //{
            //    XmlAttribute attribute = doc.CreateAttribute(_attributeName);
            //    attribute.Value = _value;
            //    XmlElement ele = (XmlElement)nodeList[i];
            //    ele.SetAttributeNode(attribute);
            //}
        }

        //存储XML文件
        doc.Save(_xmlPath);
        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return true;
    }

    /// <summary>
    /// 获取某个节点下某个属性的值
    /// </summary>
    /// <param name="_xmlPath">XML文件的路径</param>
    /// <param name="_nodeName">节点名</param>
    /// <param name="_attributeName">该节点下的属性名</param>
    /// <returns></returns>
    public static string GetAttributeValue(string _xmlPath, string _nodeName, string _attributeName)
    {
        //判断该路径下是否已存在该XML文件
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("获取节点的值失败,该路径下的文件不存在！");
            return null;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");
        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count == 1)
        {
            XmlElement ele = (XmlElement)nodeList[0];
            if (ele.GetAttributeNode(_attributeName) != null)
            {
                string value = ele.GetAttribute(_attributeName);
                if (isEncryptFile) EncrtyptSaveXML(_xmlPath);   //加密
                return value;
            }
            else if (ele.GetAttributeNode(_attributeName) == null)
            {
                Debug.Log(_nodeName + "节点下不存在属性名为" + _attributeName + "的属性");
            }
        }
        else if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
        }
        else if (nodeList.Count > 1)
        {
            Debug.LogError("在" + _xmlPath + "文件中的找到与" + _nodeName + "相同的多个节点,跳过查找!");
        }

        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return null;
    }

    /// <summary>
    /// 改变指定节点下指定属性名的值
    /// </summary>
    /// <param name="_xmlPath">XML文件路径</param>
    /// <param name="_nodeName">节点名</param>
    /// <param name="_attributeName">属性名</param>
    /// <param name="_value">需改变的值</param>
    public static bool ChangeAttributeValue(string _xmlPath, string _nodeName, string _attributeName, string _value)
    {
        //判断该路径下是否已存在此xml文件
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("修改节点的值失败,该路径下的文件不存在！");
            return false;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");
        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }
        else if (nodeList.Count == 1)
        {
            XmlElement ele = (XmlElement)nodeList[0];
            if (ele.GetAttributeNode(_attributeName) != null)
            {
                ele.SetAttribute(_attributeName, _value);
            }
            else if (ele.GetAttributeNode(_attributeName) == null)
            {
                Debug.Log(_nodeName + "节点下不存在属性名为" + _attributeName + "的属性");
                if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
                return false;
            }
        }
        else if (nodeList.Count > 1)
        {
            Debug.LogError("在" + _xmlPath + "文件中的找到与" + _nodeName + "相同的多个节点,跳过修改!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }

        //存储XML文件
        doc.Save(_xmlPath);
        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return true;
    }

    /// <summary>
    /// 删除节点
    /// </summary>
    /// <param name="_xmlPath">XML文件路径</param>
    /// <param name="_nodeName">需删除的节点名</param>
    /// <param name="_deleteStyle">true: 删除与_nodeName同级的所有名为_nodeName的节点 false: 只删除与_nodeName同级的第一个名为_nodeName的节点</param>
    public static bool DelectNode(string _xmlPath, string _nodeName, bool _deleteStyle = false)
    {
        //判断该路径下是否已存在该XML文件
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("删除节点失败,该路径下的文件不存在！");
            return false;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");
        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }
        else if (nodeList.Count == 1)
        {
            if (!_deleteStyle)
            {
                nodeList[0].ParentNode.RemoveChild(nodeList[0]);   //删除此节点时会自动删除该节点下的所有子节点
            }
            else if (_deleteStyle)
            {
                XmlNode fatherNodeList = nodeList[0].ParentNode;
                for (int i = 0; i < fatherNodeList.ChildNodes.Count; ++i)
                {
                    if (fatherNodeList.ChildNodes[i].Name == nodeList[0].Name)
                    {
                        List<XmlNode> temp = FindNode(nodeList[0].Name, root);
                        if (temp.Count == 1)
                        {
                            fatherNodeList.RemoveChild(temp[0]);
                            if (i < fatherNodeList.ChildNodes.Count) i -= 1;
                        }
                    }
                }
            }
        }
        else if (nodeList.Count > 1)
        {
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }

        //存储XML文件
        doc.Save(_xmlPath);

        //操作完成后重新加密文件
        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);

        return true;
    }

    /// <summary>
    /// 获取指定节点下的儿子节点(不包括孙子节点)
    /// </summary>
    /// <param name="_xmlPath"></param>
    /// <param name="_nodeName"></param>
    /// <returns></returns>
    public static XmlNodeList GetChildNodes(string _xmlPath, string _nodeName)
    {
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("该路径下的文件不存在！");
            return null;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");

        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
        }
        else if (nodeList.Count == 1)
        {
            XmlNodeList childs = nodeList[0].ChildNodes;
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return childs;
        }
        else if (nodeList.Count >= 1)
        {
            Debug.LogError("在" + _xmlPath + "文件中的找到与" + _nodeName + "相同的多个节点,跳过查找!");
        }

        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return null;
    }

    /// <summary>
    /// 设置节点的InnerText值
    /// 1.节点名为_nodeName的节点有子节点时,此设置会将子节点数据自动清除;
    /// 2.设置了InnerText值的节点无法添加子节点;
    /// </summary>
    /// <param name="_xmlPath"></param>
    /// <param name="_nodeName"></param>
    /// <param name="_text"></param>
    /// <returns></returns>
    public static bool SetNodeInnerText(string _xmlPath, string _nodeName, string _text)
    {
        //判断该路径下是否已存在该XML文件
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("删除节点失败,该路径下的文件不存在！");
            return false;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");
        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }
        else if (nodeList.Count == 1)
        {
            nodeList[0].InnerText = _text;
        }
        else if (nodeList.Count > 1)
        {
            Debug.LogError("在" + _xmlPath + "文件中的找到与" + _nodeName + "相同的多个节点,跳过设置!");
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return false;
        }

        //存储XML文件
        doc.Save(_xmlPath);
        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return true;
    }

    /// <summary>
    /// 获取节点的InnerText值
    /// </summary>
    /// <param name="_xmlPath"></param>
    /// <param name="_nodeName"></param>
    /// <returns></returns>
    public static string GetNodeInnerText(string _xmlPath, string _nodeName)
    {
        //判断该路径下是否已存在该XML文件
        if (!File.Exists(_xmlPath))
        {
            Debug.Log("删除节点失败,该路径下的文件不存在！");
            return null;
        }

        //加载xml文件,如果为加密的XML文件,则自动解密
        bool isEncryptFile;
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load(_xmlPath);
            isEncryptFile = false;
        }
        catch
        {
            DecrtyptLoadXML(_xmlPath);
            doc.Load(_xmlPath);
            isEncryptFile = true;
        }

        XmlNode root = doc.SelectSingleNode("Root");
        List<XmlNode> nodeList = FindNode(_nodeName, root);
        if (nodeList.Count <= 0)
        {
            //Debug.Log("遍历完成,但未找到" + _xmlPath + "文件中的" + _nodeName + "节点!");
        }
        else if (nodeList.Count == 1)
        {
            string str = nodeList[0].InnerText;
            if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
            return str;
        }
        else if (nodeList.Count > 1)
        {
            Debug.LogError("在" + _xmlPath + "文件中的找到与" + _nodeName + "相同的多个节点,跳过查找!");
        }

        if (isEncryptFile) EncrtyptSaveXML(_xmlPath);
        return null;
    }

    /// <summary>
    /// 加密XML文件 (对解密的XML文件进行加密, 可以执行多次,影响解密函数的执行次数)
    /// </summary>
    /// <param name="_xmlPath"></param>
    public static void EncrtyptSaveXML(string _xmlPath)
    {
        try
        {
            StreamReader sReader = File.OpenText(_xmlPath);
            string xmlData = sReader.ReadToEnd();
            sReader.Close();
            string xxx = Encrypt(xmlData);
            StreamWriter writer;
            writer = File.CreateText(_xmlPath);
            writer.Write(xxx);
            writer.Close();
        }
        catch
        {
            Debug.Log("加密" + _xmlPath + "文件出错!!");
        }
    }

    /// <summary>
    /// 解密XML文件 (对加密的XML文件进行解密, 且加了几次密对应就要调用相应次数的解密函数)
    /// </summary>
    /// <param name="_xmlPath"></param>
    public static void DecrtyptLoadXML(string _xmlPath)
    {
        if (File.Exists(_xmlPath))
        {
            try
            {
                StreamReader sReader = File.OpenText(_xmlPath);
                string xmlData = sReader.ReadToEnd();
                sReader.Close();
                string xxx = Decrypt(xmlData);
                StreamWriter writer;
                writer = File.CreateText(_xmlPath);
                writer.Write(xxx);
                writer.Close();
            }
            catch
            {
                Debug.Log("解密" + _xmlPath + "文件出错!!");
            }
        }
    }

    /// <summary>
    /// 遍历指定XML文件中所有节点,查找其指定节点名的节点
    /// </summary>
    /// <param name="_nodeName">需遍历的节点名</param>
    /// <param name="_rootNode">根节点</param>
    /// <returns>只返回第一次找到的节点,后面还有同名的节点还没有做处理</returns>
    private static List<XmlNode> FindNode(string _nodeName, XmlNode _rootNode)
    {
        List<XmlNode> nodeList = new List<XmlNode>();

        /* 先找父节点下所有的儿子节点,如果有,则返回,
         * 否则再找所有的孙子节点,以此类推; */

        //父节点
        List<XmlNode> fatherNodeList = new List<XmlNode>();
        fatherNodeList.Add(_rootNode);
        XmlNode temp_node = fatherNodeList[0];

        //子节点
        List<XmlNode> sonNodeList = new List<XmlNode>();
        for (int i = 0; i < fatherNodeList.Count; ++i)
        {
            for (int j = 0; j < fatherNodeList[i].ChildNodes.Count; ++j)
            {
                sonNodeList.Add(fatherNodeList[i].ChildNodes[j]);
            }
        }

        //孙子节点
        List<XmlNode> grandSonNodeList = new List<XmlNode>();
        for (int i = 0; i < sonNodeList.Count; ++i)
        {
            for (int j = 0; j < sonNodeList[i].ChildNodes.Count; ++j)
            {
                grandSonNodeList.Add(sonNodeList[i].ChildNodes[j]);
            }
        }
        
        while (true)
        {
            if (sonNodeList.Count > 0)   //判断一次firstNodeList下的儿子节点是否有重名
            {
                int SonCount = sonNodeList.Count;
                for (int i = 0; i < SonCount; ++i)
                {
                    if (sonNodeList[i].Name == _nodeName)
                    {
                        //node = sonNodeList[i];
                        //break;
                        nodeList.Add(sonNodeList[i]);
                        Debug.Log(sonNodeList[i].Name);
                    }
                    //Debug.Log(sonNodeList[i].Name);
                }

                if (grandSonNodeList.Count > 0)
                {
                    int GrandSonCount = grandSonNodeList.Count;
                    for (int i = 0; i < GrandSonCount; ++i)
                    {
                        if (grandSonNodeList[i].Name == _nodeName)
                        {
                            //node = grandSonNodeList[i];
                            //break;
                            nodeList.Add(grandSonNodeList[i]);
                            //Debug.Log(grandSonNodeList[i].Name);
                        }
                        //Debug.Log(grandSonNodeList[i].Name);
                    }
                }

                //如果没有找到,则把父,子,孙子节点链表往下一个层级赋值
                fatherNodeList.Clear();
                for (int i = 0; i < sonNodeList.Count; ++i)
                {
                    fatherNodeList.Add(sonNodeList[i]);
                }
                sonNodeList.Clear();
                if (grandSonNodeList.Count > 0)
                {
                    for (int i = 0; i < grandSonNodeList.Count; ++i)
                    {
                        sonNodeList.Add(grandSonNodeList[i]);
                    }
                    grandSonNodeList.Clear();
                    for (int i = 0; i < sonNodeList.Count; ++i)
                    {
                        for (int j = 0; j < sonNodeList[i].ChildNodes.Count; ++j)
                        {
                            grandSonNodeList.Add(sonNodeList[i].ChildNodes[j]);
                            //Debug.Log(sonNodeList[i].ChildNodes[j]);
                        }
                    }
                }
            }

            //判断是否已遍历完成
            if (sonNodeList.Count <= 0 || grandSonNodeList.Count <= 0)
            {
                break;
            }
        }
        
        return nodeList;
    }

    /// <summary>
    /// 判断指定节点链表中是否有节点名重名(找到重名的,则返回true)
    /// </summary>
    /// <param name="_nodeList">节点链表</param>
    /// <param name="_nodeName">需检测的节点名</param>
    /// <returns></returns>
    private static bool IsSameName(XmlNodeList _nodeList, string _nodeName)
    {
        int count = _nodeList.Count;
        if (_nodeName == null)
        {
            Debug.Log("检测重名的节点名不能为NULL!");
            return true;
        }

        for (int i = 0; i < count; ++i)
        {
            XmlElement element = (XmlElement)_nodeList[i];

            if (element.Name == _nodeName) return true;
        }

        return false;
    }

    /// <summary>  
    /// 内容加密,加密和解密采用相同的key,具体可以自己定义，条件是必须是32位的  
    /// </summary>  
    /// <param name="toE"></param>  
    /// <returns></returns>  
    private static string Encrypt(string toE)
    {
        byte[] keyArray = UTF8Encoding.UTF8.GetBytes("12348578902223367877723456789012");
        RijndaelManaged rDel = new RijndaelManaged();
        rDel.Key = keyArray;
        rDel.Mode = CipherMode.ECB;
        rDel.Padding = PaddingMode.PKCS7;
        ICryptoTransform cTransform = rDel.CreateEncryptor();

        byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toE);
        byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

        return Convert.ToBase64String(resultArray, 0, resultArray.Length);
    }

    /// <summary>  
    /// 内容解密，千万记住解密和加密采用相同的key，必须是32位  
    /// </summary>  
    /// <param name="toD"></param>  
    /// <returns></returns>  
    private static string Decrypt(string toD)
    {
        //加密和解密采用相同的key,具体值自己填，但是必须为32位//  
        byte[] keyArray = UTF8Encoding.UTF8.GetBytes("12348578902223367877723456789012");

        RijndaelManaged rDel = new RijndaelManaged();
        rDel.Key = keyArray;
        rDel.Mode = CipherMode.ECB;
        rDel.Padding = PaddingMode.PKCS7;
        ICryptoTransform cTransform = rDel.CreateDecryptor();

        byte[] toEncryptArray = Convert.FromBase64String(toD);
        byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

        return UTF8Encoding.UTF8.GetString(resultArray);
    }
}