實現效果
- 本輔助類主要是用來方便實現XML序列化、反序列化、節點等操作。
- 序列化是指一個對象的實例可以被保存，保存成一個二進制串或者XML等格式字符串。反序列化這是從這些內容中還原爲一個對象實例的操作。
- 要實現對象的序列化，首先要保證該對象可以序列化。而且，序列化只是將對象的屬性進行有效的保存，對於對象的一些方法則無法實現序列化的。
- 實現一個類可序列化的最簡便的方法就是增加Serializable屬性標記類。
實現步驟
實現代碼
/// 構造函數
public XmlHelper(string XmlFile)
#region 靜態方法
/// 二進制序列化
public static bool Serialize(string path, object obj)
/// XML序列化
public static bool XmlSerialize(string path, object obj, Type type)
/// 二進制反序列化
public static object Deserialize(string path)
/// XML反序列化
public static object XmlDeserialize(string path, Type type)
#endregion
#region 公用方法
/// 獲取指定節點下面的XML子節點
public XmlNodeList Read(string XmlPathNode)
/// 讀取節點屬性內容
public string Read(string XmlPathNode, string Attrib)
/// 獲取元素節點對象
public XmlElement GetElement(string XmlPathNode, string elementName)
/// 獲取元素節點的值
public string GetElementData(string XmlPathNode, string elementName)
/// 獲取節點下的DataSet
public DataSet GetData(string XmlPathNode)
/// 替換某節點的內容
public void Replace(string XmlPathNode, string Content)
/// 刪除節點
public void Delete(string Node)
/// 插入一節點和此節點的一子節點
public void InsertNode(string MainNode, string ChildNode, string Element, string Content)
/// 插入一個節點帶一個屬性
public void InsertElement(string MainNode, string Element, string Attrib, string AttribContent, string Content)
/// 插入XML元素
public void InsertElement(string MainNode, string Element, string Content)
/// 保存XML文檔
public void Save()
SearchInfo searchInfo = new SearchInfo();
searchInfo.FieldName = "TestFeild";
searchInfo.FieldValue = "TestValue";
string file = @"C:searchInfo.xml";
XmlHelper.XmlSerialize(file, searchInfo, typeof(SearchInfo));
SearchInfo info2FromXml = XmlHelper.XmlDeserialize(file, typeof(SearchInfo)) as SearchInfo;
Console.WriteLine("{0} : {0}", info2FromXml.FieldName, info2FromXml.FieldValue);
//bookstore.xml文件內容
/*
<?xml version="1.0" encoding="gb2312"?>
<bookstore>
<book genre="it" ISBN="9787302461968">
<title>C#高級編程</title>
<author>Christian Nagel</author>
<price>132.0</price>
</book>
</bookstore>
*/
string file = @"c:\\bookstore.xml";
XmlHelper helper = new XmlHelper(file);
string value = helper.Read("bookstore/book", "genre");
Console.WriteLine(value);//it
value = helper.Read("bookstore/book", "ISBN");
Console.WriteLine(value);//9787302461968
value = helper.GetElementData("bookstore/book", "title");
Console.WriteLine(value);//C#高級編程
XmlElement element = helper.GetElement("bookstore/book", "title");
element.InnerText = "程序猿日誌";
DataSet ds = helper.GetData("bookstore/book");
ds.WriteXml(@"C:ds.xml");
附上源碼
/// <summary>
/// XML序列號、反序列化、節點等操作類輔助類
/// </summary>
public class XmlHelper
{
#region 變量
/// <summary>
/// XML文件路徑
/// </summary>
protected string strXmlFile;
/// <summary>
/// XmlDocument對象
/// </summary>
protected XmlDocument objXmlDoc = new XmlDocument();
#endregion
/// <summary>
/// 構造函數
/// </summary>
/// <param name="XmlFile">XML文件路徑</param>
public XmlHelper(string XmlFile)
{
try
{
objXmlDoc.Load(XmlFile);
}
catch (System.Exception ex)
{
throw ex;
}
strXmlFile = XmlFile;
}
#region 靜態方法
/// <summary>
/// 二進制序列化
/// </summary>
/// <param name="path">文件路徑</param>
/// <param name="obj">對象實例</param>
/// <returns></returns>
public static bool Serialize(string path, object obj)
{
try
{
using (Stream stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
IFormatter format = new BinaryFormatter();
format.Serialize(stream, obj);
stream.Close();
}
return true;
}
catch
{
return false;
}
}
/// <summary>
/// XML序列化
/// </summary>
/// <param name="path">文件路徑</param>
/// <param name="obj">對象實例</param>
/// <param name="type">對象類型</param>
/// <returns></returns>
public static bool XmlSerialize(string path, object obj, Type type)
{
try
{
if (!File.Exists(path))
{
FileInfo fi = new FileInfo(path);
if (!fi.Directory.Exists)
{
Directory.CreateDirectory(fi.Directory.FullName);
}
}
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
using (Stream stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
XmlSerializer format = new XmlSerializer(type);
format.Serialize(stream, obj, ns);
stream.Close();
}
return true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return false;
}
}
/// <summary>
/// 二進制反序列化
/// </summary>
/// <param name="path">文件路徑</param>
/// <returns></returns>
public static object Deserialize(string path)
{
try
{
using (Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
IFormatter formatter = new BinaryFormatter();
stream.Seek(0, SeekOrigin.Begin);
object obj = formatter.Deserialize(stream);
stream.Close();
return obj;
}
}
catch
{
return null;
}
}
/// <summary>
/// XML反序列化
/// </summary>
/// <param name="path">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns></returns>
public static object XmlDeserialize(string path, Type type)
{
try
{
using (Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
XmlSerializer formatter = new XmlSerializer(type);
stream.Seek(0, SeekOrigin.Begin);
object obj = formatter.Deserialize(stream);
stream.Close();
return obj;
}
}
catch
{
return null;
}
}
#endregion
#region 公用方法
/// <summary>
/// 獲取指定節點下面的XML子節點
/// </summary>
/// <param name="XmlPathNode">XML節點</param>
/// <returns></returns>
public XmlNodeList Read(string XmlPathNode)
{
try
{
XmlNode xn = objXmlDoc.SelectSingleNode(XmlPathNode);
return xn.ChildNodes;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 讀取節點屬性內容
/// </summary>
/// <param name="XmlPathNode">XML節點</param>
/// <param name="Attrib">節點屬性</param>
/// <returns></returns>
public string Read(string XmlPathNode, string Attrib)
{
string value = "";
try
{
XmlNode xn = objXmlDoc.SelectSingleNode(XmlPathNode);
value = (Attrib.Equals("") ? xn.InnerText : xn.Attributes[Attrib].Value);
}
catch (Exception ex)
{
throw ex;
}
return value;
}
/// <summary>
/// 獲取元素節點對象
/// </summary>
/// <param name="XmlPathNode">XML節點</param>
/// <param name="elementName">元素節點名稱</param>
/// <returns></returns>
public XmlElement GetElement(string XmlPathNode, string elementName)
{
XmlElement result = null;
XmlNode nls = objXmlDoc.SelectSingleNode(XmlPathNode);
foreach (XmlNode xn1 in nls)//遍歷
{
XmlElement xe2 = (XmlElement)xn1;//轉換類型
if (xe2.Name == elementName)//如果找到
{
result = xe2;
break;//找到退出來就可以了
}
}
return result;
}
/// <summary>
/// 獲取元素節點的值
/// </summary>
/// <param name="XmlPathNode">XML節點</param>
/// <param name="elementName">元素節點名稱</param>
/// <returns></returns>
public string GetElementData(string XmlPathNode, string elementName)
{
string result = null;
XmlNode nls = objXmlDoc.SelectSingleNode(XmlPathNode);
foreach (XmlNode xn1 in nls)//遍歷
{
XmlElement xe2 = (XmlElement)xn1;//轉換類型
if (xe2.Name == elementName)//如果找到
{
result = xe2.InnerText;
break;//找到退出來就可以了
}
}
return result;
}
/// <summary>
/// 獲取節點下的DataSet
/// </summary>
/// <param name="XmlPathNode">XML節點</param>
/// <returns></returns>
public DataSet GetData(string XmlPathNode)
{
DataSet ds = new DataSet();
StringReader read = new StringReader(objXmlDoc.SelectSingleNode(XmlPathNode).OuterXml);
ds.ReadXml(read);
return ds;
}
/// <summary>
/// 替換某節點的內容
/// </summary>
/// <param name="XmlPathNode">XML節點</param>
/// <param name="Content">節點內容</param>
public void Replace(string XmlPathNode, string Content)
{
objXmlDoc.SelectSingleNode(XmlPathNode).InnerText = Content;
}
/// <summary>
/// 刪除節點
/// </summary>
/// <param name="Node">節點</param>
public void Delete(string Node)
{
string mainNode = Node.Substring(0, Node.LastIndexOf("/")); objXmlDoc.SelectSingleNode(mainNode).RemoveChild(objXmlDoc.SelectSingleNode(Node));
}
/// <summary>
/// 插入一節點和此節點的一子節點
/// </summary>
/// <param name="MainNode"></param>
/// <param name="ChildNode"></param>
/// <param name="Element"></param>
/// <param name="Content"></param>
public void InsertNode(string MainNode, string ChildNode, string Element, string Content)
{
XmlNode objRootNode = objXmlDoc.SelectSingleNode(MainNode);
XmlElement objChildNode = objXmlDoc.CreateElement(ChildNode);
objRootNode.AppendChild(objChildNode);
XmlElement objElement = objXmlDoc.CreateElement(Element);
objElement.InnerText = Content;
objChildNode.AppendChild(objElement);
}
/// <summary>
/// 插入一個節點帶一個屬性
/// </summary>
/// <param name="MainNode">指定的XML節點</param>
/// <param name="Element">元素名稱</param>
/// <param name="Attrib">屬性名稱</param>
/// <param name="AttribContent">屬性值</param>
/// <param name="Content">內容</param>
public void InsertElement(string MainNode, string Element, string Attrib, string AttribContent, string Content)
{
XmlNode objNode = objXmlDoc.SelectSingleNode(MainNode);
XmlElement objElement = objXmlDoc.CreateElement(Element);
objElement.SetAttribute(Attrib, AttribContent);
objElement.InnerText = Content;
objNode.AppendChild(objElement);
}
/// <summary>
/// 插入XML元素
/// </summary>
/// <param name="MainNode">指定的XML節點</param>
/// <param name="Element">元素名稱</param>
/// <param name="Content">內容</param>
public void InsertElement(string MainNode, string Element, string Content)
{
XmlNode objNode = objXmlDoc.SelectSingleNode(MainNode);
XmlElement objElement = objXmlDoc.CreateElement(Element);
objElement.InnerText = Content;
objNode.AppendChild(objElement);
}
/// <summary>
/// 保存XML文檔
/// </summary>
public void Save()
{
try
{
objXmlDoc.Save(strXmlFile);
}
catch (System.Exception ex)
{
throw ex;
}
objXmlDoc = null;
}
/// <summary>
/// XML序列化並對文件進行加密
/// </summary>
/// <param name="path">文件路徑</param>
/// <param name="obj">對象實例</param>
/// <param name="type">對象類型</param>
/// <returns></returns>
public bool XmlSerializeEncrypt(string path, object obj, Type type)
{
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
try
{
if (!File.Exists(path))
{
FileInfo fi = new FileInfo(path);
if (!fi.Directory.Exists)
{
Directory.CreateDirectory(fi.Directory.FullName);
}
}
using (Stream stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
string content = "";
using (MemoryStream ms = new MemoryStream())
{
XmlSerializer format = new XmlSerializer(type);
format.Serialize(ms, obj, ns);
ms.Seek(0, 0);
content = Encoding.ASCII.GetString(ms.ToArray());
}
string encrypt = EncodeHelper.EncryptString(content);
byte[] bytes = UTF8Encoding.Default.GetBytes(encrypt);
stream.Write(bytes, 0, bytes.Length);
stream.Close();
}
return true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return false;
}
}
/// <summary>
/// XML反序列化並解密
/// </summary>
/// <param name="path">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns></returns>
public object XmlDeserializeDecrypt(string path, Type type)
{
try
{
string encrypt = File.ReadAllText(path, Encoding.UTF8);
string content = EncodeHelper.DecryptString(encrypt, true);
byte[] bytes = UTF8Encoding.Default.GetBytes(content);
using (MemoryStream stream = new MemoryStream(bytes))
{
XmlSerializer formatter = new XmlSerializer(type);
stream.Seek(0, SeekOrigin.Begin);
object obj = formatter.Deserialize(stream);
stream.Close();
return obj;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return null;
}
}
#endregion
}
