下面的代码主要是把对象序列化为JSON格式或XML格式等
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Xml.Serialization;
using System.Reflection;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization; namespace LighTake.Infrastructure.Common
{
/// <summary>
/// 序列化及反序列化的辅助类
/// </summary>
public static class SerializeUtil
{ /// <summary>
/// 将对象序列化为二进制字节
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <returns></returns>
public static byte[] SerializeToBinary(object obj)
{
byte[] bytes = new byte[];
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryFormatter bformatter = new BinaryFormatter();
bformatter.Serialize(memoryStream, obj);
memoryStream.Seek(, ); if (memoryStream.Length > bytes.Length)
{
bytes = new byte[memoryStream.Length];
}
bytes = memoryStream.ToArray();
}
return bytes;
} /// <summary>
/// 将文件对象序列化到文件中
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <param name="path">文件路径</param>
/// <param name="fileMode">文件打开模式</param>
public static void SerializeToBinary(object obj, string path, FileMode fileMode)
{
using (FileStream fs = new FileStream(path, fileMode))
{
// Construct a BinaryFormatter and use it to serialize the data to the stream.
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, obj);
}
} /// <summary>
/// 将文件对象序列化到文件中
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <param name="path">文件路径</param>
public static void SerializeToBinary(object obj, string path)
{
SerializeToBinary(obj, path, FileMode.Create);
} /// <summary>
/// 将对象序列化为XML字符串
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <returns>XML字符串</returns>
public static string SerializeToXml(object obj)
{
string xml = "";
using (MemoryStream memoryStream = new MemoryStream())
{
XmlSerializer serializer = new XmlSerializer(obj.GetType());
serializer.Serialize(memoryStream, obj);
memoryStream.Seek(, );
xml = Encoding.UTF8.GetString(memoryStream.ToArray());
} return xml;
} public static string SerializeToXml(object obj, XmlSerializerNamespaces namespaces)
{
if (obj == null)
return null; if (namespaces == null)
{
namespaces = new XmlSerializerNamespaces();
namespaces.Add(string.Empty, string.Empty);
} string xml = "";
using (MemoryStream memoryStream = new MemoryStream())
{
XmlSerializer serializer = new XmlSerializer(obj.GetType());
serializer.Serialize(memoryStream, obj, namespaces);
memoryStream.Seek(, );
xml = Encoding.UTF8.GetString(memoryStream.ToArray());
} return xml;
} public static string SerializeToXml(object obj, XmlSerializerNamespaces namespaces, XmlAttributeOverrides attrs)
{
if (namespaces == null)
{
namespaces = new XmlSerializerNamespaces();
namespaces.Add(string.Empty, string.Empty);
} string xml = "";
using (MemoryStream memoryStream = new MemoryStream())
{
XmlSerializer serializer = new XmlSerializer(obj.GetType(), attrs);
serializer.Serialize(memoryStream, obj, namespaces);
memoryStream.Seek(, );
xml = Encoding.UTF8.GetString(memoryStream.ToArray());
} return xml;
} /// <summary>
/// 将对象序列化为XML字符串并保存到文件
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <param name="path">保存的文件路径</param>
/// <param name="fileMode">文件打开模式</param>
public static void SerializeToXmlFile(object obj, string path, FileMode fileMode)
{
using (FileStream fileStream = new FileStream(path, fileMode))
{
// Construct a BinaryFormatter and use it to serialize the data to the stream.
XmlSerializer serializer = new XmlSerializer(obj.GetType());
serializer.Serialize(fileStream, obj);
}
} /// <summary>
/// 将对象序列化为XML字符串并保存到文件
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <param name="path">保存的文件路径</param>
public static void SerializeToXmlFile(object obj, string path)
{
SerializeToXmlFile(obj, path, FileMode.Create);
} /// <summary>
/// 从XML文件中反序列化为Object对象
/// </summary>
/// <param name="type">对象的类型</param>
/// <param name="path">XML文件</param>
/// <returns>反序列化后得到的对象</returns>
public static object DeserializeFromXmlFile(Type type, string path)
{
object result = new object();
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
XmlSerializer serializer = new XmlSerializer(type);
result = serializer.Deserialize(fileStream);
} return result;
} /// <summary>
/// 从XML文件中反序列化为对象
/// </summary>
/// <param name="type">对象的类型</param>
/// <param name="xml">XML字符串</param>
/// <returns>反序列化后得到的对象</returns>
public static object DeserializeFromXml(Type type, string xml)
{
object result = new object();
XmlSerializer serializer = new XmlSerializer(type);
result = serializer.Deserialize(new StringReader(xml)); return result;
} /// <summary>
/// 从XML文件中反序列化为对象
/// </summary>
public static T DeserializeFromXml<T>(string xml)
{
T result = default(T);
var serializer = new XmlSerializer(typeof(T));
result = (T)serializer.Deserialize(new StringReader(xml)); return result;
} public static T DeserializeFromXml<T>(string xml, XmlAttributeOverrides attrs)
{
T result = default(T);
var serializer = new XmlSerializer(typeof(T), attrs);
result = (T)serializer.Deserialize(new StringReader(xml)); return result;
} /// <summary>
/// 从二进制字节中反序列化为对象
/// </summary>
/// <param name="type">对象的类型</param>
/// <param name="bytes">字节数组</param>
/// <returns>反序列化后得到的对象</returns>
public static object DeserializeFromBinary(Type type, byte[] bytes)
{
object result = new object();
using (MemoryStream memoryStream = new MemoryStream(bytes))
{
BinaryFormatter serializer = new BinaryFormatter();
result = serializer.Deserialize(memoryStream);
} return result;
} /// <summary>
/// 从二进制文件中反序列化为对象
/// </summary>
/// <param name="type">对象的类型</param>
/// <param name="path">二进制文件路径</param>
/// <returns>反序列化后得到的对象</returns>
public static object DeserializeFromBinary(Type type, string path)
{
object result = new object();
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
BinaryFormatter serializer = new BinaryFormatter();
result = serializer.Deserialize(fileStream);
} return result;
} /// <summary>
/// 获取对象的转换为二进制的字节大小
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static long GetByteSize(object obj)
{
long result;
BinaryFormatter bFormatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
bFormatter.Serialize(stream, obj);
result = stream.Length;
}
return result;
} /// <summary>
/// 克隆一个对象
/// </summary>
/// <param name="obj">待克隆的对象</param>
/// <returns>克隆的一个新的对象</returns>
public static object Clone(object obj)
{
object cloned = null;
BinaryFormatter bFormatter = new BinaryFormatter();
using (MemoryStream memoryStream = new MemoryStream())
{
try
{
bFormatter.Serialize(memoryStream, obj);
memoryStream.Seek(, SeekOrigin.Begin);
cloned = bFormatter.Deserialize(memoryStream);
}
catch //(Exception e)
{
;
}
} return cloned;
} /// <summary>
/// 从文件中读取文本内容
/// </summary>
/// <param name="path">文件路径</param>
/// <returns>文件的内容</returns>
public static string ReadFile(string path)
{
string content = string.Empty;
using (StreamReader reader = new StreamReader(path))
{
content = reader.ReadToEnd();
} return content;
} /// <summary>
/// 读取嵌入资源的文本内容
/// </summary>
/// <param name="fileWholeName">包含命名空间的嵌入资源文件名路径</param>
/// <returns>文件中的文本内容</returns>
public static string ReadFileFromEmbedded(string fileWholeName)
{
string result = string.Empty; Assembly assembly = Assembly.GetEntryAssembly();
using (TextReader reader = new StreamReader(assembly.GetManifestResourceStream(fileWholeName)))
{
result = reader.ReadToEnd();
} return result;
} #region /*序列化和反序列化*/ public static string ToXml<T>(this T value)
{
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
namespaces.Add(string.Empty, string.Empty);
XmlSerializer serializer = new XmlSerializer(typeof(T));
StringWriter textWriter = new StringWriter(new StringBuilder(), CultureInfo.CurrentCulture);
serializer.Serialize(textWriter, value, namespaces);
string str = textWriter.ToString();
textWriter.Close();
return str;
} public static T FromXml<T>(this string xml)
{
T local = default(T);
if (!string.IsNullOrWhiteSpace(xml))
{
try
{
TextReader textReader = new StringReader(xml);
XmlSerializer serializer = new XmlSerializer(typeof(T));
local = (T)serializer.Deserialize(textReader);
textReader.Close();
return local;
}
catch
{
}
}
return local;
} /// <summary>
/// 将对象序列化为JSON
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string ToJson<T>(this T obj)
{
if ((object)obj == null)
{
return string.Empty;
}
return JsonConvert.SerializeObject(obj);
} /// <summary>
/// 将JSON字符串反序列化为对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonString"></param>
/// <returns></returns>
public static T FromJson<T>(this string jsonString)
{
if (jsonString.IsNullOrWhiteSpace())
{
return default(T);
}
return JsonConvert.DeserializeObject<T>(jsonString);
} #endregion
}
}