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.L
4000
oad(_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)
{
XmlNo
e2f0
deList 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);
}
}