using System.IO;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.Runtime.Serialization.Json;
using System;
namespace cn.ava.PublicsUtil.Util
{
/// <summary>
/// 建立人Rex.liu
/// 建立時間：2015年9月6日 14:48:29
/// 功能：序列化反序列化XML檔案
/// </summary>
public class JsonAndXmlSerialization
{
#region 外部調用
/// <summary>
/// 将對象根據格式（XML/JSON）序列化成字元串結果
/// </summary>
/// <param name="o">目标對象</param>
/// <param name="format">輸出格式</param>
/// <returns></returns>
public static string Serialize(object o, string format)
{
if (format.ToLower() == "xml")
{
return JsonAndXmlSerialization.XmlSerialize(o);
}
else
{
return JsonAndXmlSerialization.JsonSerialize(o);
}
}
/// <summary>
/// 将字元串根據格式（XML/JSON）反序列化成指定類型的對象
/// </summary>
/// <typeparam name="T">指定類型</typeparam>
/// <param name="s">目标字元串</param>
/// <param name="format">輸入格式</param>
/// <returns></returns>
public static T Deserialize<T>(string s, string format)
{
if (format.ToLower() == "xml")
{
return JsonAndXmlSerialization.XmlDeserialize<T>(s);
}
else
{
return JsonAndXmlSerialization.JsonDeserialize<T>(s);
}
}
/// <summary>
/// 對象序列化成檔案并儲存
/// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="t">對象實體</param>
/// <param name="path">檔案路徑</param>
/// <param name="format">格式：json或 xml</param>
/// <returns></returns>
public static bool SerializableFile<T>(object t, string path, string format)
{
if (format.ToLower() == "xml")
{
return JsonAndXmlSerialization.SerializableXML<T>(t, path);
}
else
{
return JsonAndXmlSerialization.SerializableJson<T>(t, path);
}
}
/// <summary>
/// 将檔案反序列化成對象
/// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="path">檔案路徑</param>
/// <param name="format">格式： json 或 xml</param>
/// <returns></returns>
public static T DeserializeFile<T>(string path, string format)
{
if (format.ToLower() == "xml")
{
return JsonAndXmlSerialization.DeSerializableXML<T>(path);
}
else
{
return JsonAndXmlSerialization.DeSerializableJson<T>(path);
}
}
#endregion
#region 對象的序列化與反序列化
/// <summary>
/// 将object對象序列化成XML
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
private static string XmlSerialize(object o)
{
XmlSerializer ser = new XmlSerializer(o.GetType());
System.IO.MemoryStream mem = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(mem, Encoding.UTF8);
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
ser.Serialize(writer, o, ns);
writer.Close();
return Encoding.UTF8.GetString(mem.ToArray());
}
/// <summary>
/// 字元串反序列化成對象
/// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="s">XML值</param>
/// <returns></returns>
private static T XmlDeserialize<T>(string s)
{
XmlDocument xdoc = new XmlDocument();
try
{
xdoc.LoadXml(s);
XmlNodeReader reader = new XmlNodeReader(xdoc.DocumentElement);
XmlSerializer ser = new XmlSerializer(typeof(T));
object obj = ser.Deserialize(reader);
return (T)obj;
}
catch
{
return default(T);
}
}
/// <summary>
/// 對象序列化成Json字元串
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
private static string JsonSerialize(object o)
{
using (var ms = new MemoryStream())
{
new DataContractJsonSerializer(o.GetType()).WriteObject(ms, o);
return Encoding.UTF8.GetString(ms.ToArray());
}
}
/// <summary>
/// Json字元串反序列化成對象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="s"></param>
/// <returns></returns>
private static T JsonDeserialize<T>(string s)
{
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(s)))
{
return (T)new DataContractJsonSerializer(typeof(T)).ReadObject(ms);
}
}
#endregion
#region 将對象儲存成檔案
/// <summary>
/// 将對象儲存為json檔案
/// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="t">對象</param>
/// <param name="path">儲存路徑</param>
/// <returns></returns>
private static bool SerializableJson<T>(object t, string path)
{
bool bl = false;
try
{
string strjson = JsonSerialize(t);
System.IO.StreamWriter sw = System.IO.File.CreateText(path);
sw.WriteLine(strjson);
sw.Close();
}
catch
{
return bl;
}
return true;
}
/// <summary>
/// 将對象序列化成XML并儲存到檔案
/// </summary>
/// <returns></returns>
private static bool SerializableXML<T>(object t, string path)
{
bool bl = false;
FileStream fileStream = null;
try
{
if (t != null)
{
//建立xml格式器
XmlSerializer xmls = new XmlSerializer(typeof(T));
//建立檔案流
fileStream = new FileStream(path, FileMode.Create);
//将對象序列化到流
xmls.Serialize(fileStream, t);
bl = true;
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (fileStream != null)
{
fileStream.Close();
}
}
return bl;
}
#endregion
#region 将檔案反序列化成對象
/// <summary>
/// 将檔案反序列化json
/// </summary>
/// <typeparam name="T">類型</typeparam>
/// <param name="path">json所存放的路徑</param>
/// <returns>實體</returns>
private static T DeSerializableJson<T>(string path)
{
T t = default(T);
try
{
FileInfo fi = new FileInfo(path);
if (fi.Exists)
{
StreamReader sr = new StreamReader(path, Encoding.UTF8);
String line;
StringBuilder strcontent = new StringBuilder();
while ((line = sr.ReadLine()) != null)
{
strcontent.Append(line.ToString());
}
t = JsonAndXmlSerialization.JsonDeserialize<T>(strcontent.ToString());
}
}
catch (Exception ex)
{
throw ex;
}
return t;
}
/// <summary>
/// 将檔案反序列化XML
/// </summary>
/// <typeparam name="T">類型</typeparam>
/// <param name="path">XMl所存放的路徑</param>
/// <returns>實體</returns>
private static T DeSerializableXML<T>(string path)
{
T t = default(T);
FileStream fileStream = null;
try
{
XmlSerializer xmls = new XmlSerializer(typeof(T));
FileInfo fi = new FileInfo(path);
if (fi.Exists)
{
fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
t = (T)xmls.Deserialize(fileStream);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (fileStream != null)
{
fileStream.Close();
}
}
return t;
}
#endregion
}
}
![Ajax——模闆引擎[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)