xml序列化方式
2015-05-28 11:26
232 查看
public static class MySerializeXmlHelper
{
static MySerializeXmlHelper() { }
private static object _lock = new object();
#region 泛型支持
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name=“T“>需要序列化的对象类型,不必须声明[Serializable]特征</typeparam>
/// <param name=“obj“>需要序列化的对象</param>
/// <returns></returns>
public static string SerializeToXmlText<T>(T obj)
{
Type t = obj.GetType();
return SerializeToXmlText(obj, t);
}
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name=“T“>需要序列化的对象类型,不必须声明[Serializable]特征</typeparam>
/// <param name=“obj“>需要序列化的对象</param>
/// <param name="ignoreNamespace">是否忽略命名空间(默认true)</param>
/// <returns></returns>
public static string SerializeToXmlText<T>(T obj, bool ignoreNamespace = true)
{
//Type t = typeof(T);
Type t = obj.GetType();
return SerializeToXmlText(obj, t, ignoreNamespace);
}
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name=“T“>需要序列化的对象类型,不必须声明[Serializable]特征</typeparam>
/// <param name=“obj“>需要序列化的对象</param>
/// <param name="filePath"></param>
public static void SerializeFile<T>(T obj, string filePath)
{
//Type t = typeof(T);
Type t = obj.GetType();
SerializeFile(obj, t, filePath);
}
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="filePath"></param>
public static void SerializeFile<T>(T obj, string filePath, bool ignoreNamespace = true)
{
//Type t = typeof(T);
Type t = obj.GetType();
SerializeFile(obj, t, filePath, ignoreNamespace);
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <param name=“xmlOfObject“>需要反序列化的xml字符串</param>
public static T DeserializeFromXmlText<T>(string xmlOfObject)
{
Type t = typeof(T);
return (T)DeserializeFromXmlText(xmlOfObject, t);
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="filePath"></param>
/// <returns></returns>
public static T DeSerializeFile<T>(string filePath)
{
Type t = typeof(T);
return (T)DeSerializeFile(filePath, t);
}
#endregion
#region 非泛型支持
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="t"></param>
/// <returns></returns>
public static string SerializeToXmlText(object obj, Type t)
{
return SerializeToXmlText(obj, t, true);
}
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="t"></param>
/// <param name="ignoreNamespace"></param>
/// <returns>序列化的xml字符串</returns>
public static string SerializeToXmlText(object obj, Type t, bool ignoreNamespace =true)
{
using (MemoryStream ms = new MemoryStream())
{
XmlSerializer serializer = new XmlSerializer(t);
if (ignoreNamespace)
{
//使其不生成命名空间属性
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
serializer.Serialize(ms, obj, ns);
}
else
{
serializer.Serialize(ms, obj);
}
ms.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(ms, Encoding.UTF8))
{
return reader.ReadToEnd();
}
}
}
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="filePath"></param>
/// <param name="t"></param>
public static void SerializeFile(object obj, Type t, string filePath)
{
SerializeFile(obj, t, filePath, true);
}
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="filePath"></param>
/// <param name="t"></param>
/// <param name="ignoreNamespace"></param>
public static void SerializeFile(object obj, Type t, string filePath, bool ignoreNamespace = true)
{
string temp = SerializeToXmlText(obj, t, ignoreNamespace);
using (StreamWriter sw = File.CreateText(filePath))
{
sw.WriteLine(temp);
sw.Close();
}
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <param name=“xmlOfObject“>需要反序列化的xml字符串</param>
/// <param name="t"></param>
/// <returns></returns>
public static object DeserializeFromXmlText(string xmlOfObject, Type t)
{
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter sr = new StreamWriter(ms, Encoding.UTF8))
{
sr.Write(xmlOfObject);
sr.Flush();
ms.Seek(0, SeekOrigin.Begin);
XmlSerializer serializer = new XmlSerializer(t);
return serializer.Deserialize(ms);
}
}
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="filePath"></param>
/// <returns></returns>
public static object DeSerializeFile(string filePath, Type t)
{
string temp = File.ReadAllText(filePath, Encoding.UTF8);
return DeserializeFromXmlText(temp, t);
}
#endregion
}
{
static MySerializeXmlHelper() { }
private static object _lock = new object();
#region 泛型支持
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name=“T“>需要序列化的对象类型,不必须声明[Serializable]特征</typeparam>
/// <param name=“obj“>需要序列化的对象</param>
/// <returns></returns>
public static string SerializeToXmlText<T>(T obj)
{
Type t = obj.GetType();
return SerializeToXmlText(obj, t);
}
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name=“T“>需要序列化的对象类型,不必须声明[Serializable]特征</typeparam>
/// <param name=“obj“>需要序列化的对象</param>
/// <param name="ignoreNamespace">是否忽略命名空间(默认true)</param>
/// <returns></returns>
public static string SerializeToXmlText<T>(T obj, bool ignoreNamespace = true)
{
//Type t = typeof(T);
Type t = obj.GetType();
return SerializeToXmlText(obj, t, ignoreNamespace);
}
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name=“T“>需要序列化的对象类型,不必须声明[Serializable]特征</typeparam>
/// <param name=“obj“>需要序列化的对象</param>
/// <param name="filePath"></param>
public static void SerializeFile<T>(T obj, string filePath)
{
//Type t = typeof(T);
Type t = obj.GetType();
SerializeFile(obj, t, filePath);
}
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="filePath"></param>
public static void SerializeFile<T>(T obj, string filePath, bool ignoreNamespace = true)
{
//Type t = typeof(T);
Type t = obj.GetType();
SerializeFile(obj, t, filePath, ignoreNamespace);
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <param name=“xmlOfObject“>需要反序列化的xml字符串</param>
public static T DeserializeFromXmlText<T>(string xmlOfObject)
{
Type t = typeof(T);
return (T)DeserializeFromXmlText(xmlOfObject, t);
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="filePath"></param>
/// <returns></returns>
public static T DeSerializeFile<T>(string filePath)
{
Type t = typeof(T);
return (T)DeSerializeFile(filePath, t);
}
#endregion
#region 非泛型支持
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="t"></param>
/// <returns></returns>
public static string SerializeToXmlText(object obj, Type t)
{
return SerializeToXmlText(obj, t, true);
}
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="t"></param>
/// <param name="ignoreNamespace"></param>
/// <returns>序列化的xml字符串</returns>
public static string SerializeToXmlText(object obj, Type t, bool ignoreNamespace =true)
{
using (MemoryStream ms = new MemoryStream())
{
XmlSerializer serializer = new XmlSerializer(t);
if (ignoreNamespace)
{
//使其不生成命名空间属性
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
serializer.Serialize(ms, obj, ns);
}
else
{
serializer.Serialize(ms, obj);
}
ms.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(ms, Encoding.UTF8))
{
return reader.ReadToEnd();
}
}
}
//为不支持动态参数的老接口保留,请勿删除此方法
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="filePath"></param>
/// <param name="t"></param>
public static void SerializeFile(object obj, Type t, string filePath)
{
SerializeFile(obj, t, filePath, true);
}
/// <summary>
/// 使用XmlSerializer序列化对象(不必须声明[Serializable]特征)
/// </summary>
/// <param name="obj"></param>
/// <param name="filePath"></param>
/// <param name="t"></param>
/// <param name="ignoreNamespace"></param>
public static void SerializeFile(object obj, Type t, string filePath, bool ignoreNamespace = true)
{
string temp = SerializeToXmlText(obj, t, ignoreNamespace);
using (StreamWriter sw = File.CreateText(filePath))
{
sw.WriteLine(temp);
sw.Close();
}
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <param name=“xmlOfObject“>需要反序列化的xml字符串</param>
/// <param name="t"></param>
/// <returns></returns>
public static object DeserializeFromXmlText(string xmlOfObject, Type t)
{
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter sr = new StreamWriter(ms, Encoding.UTF8))
{
sr.Write(xmlOfObject);
sr.Flush();
ms.Seek(0, SeekOrigin.Begin);
XmlSerializer serializer = new XmlSerializer(t);
return serializer.Deserialize(ms);
}
}
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="filePath"></param>
/// <returns></returns>
public static object DeSerializeFile(string filePath, Type t)
{
string temp = File.ReadAllText(filePath, Encoding.UTF8);
return DeserializeFromXmlText(temp, t);
}
#endregion
}
相关文章推荐
- unity中三种数据存储方式ScriptableObject,Json,Xml和Dictionary的序列化
- DataContract方式做对象的XML序列化可能出现的BUG
- 对象的序列化与反序列化,以xml,二进制流的方式,soap方式序列化对象
- XML的序列化读取方式
- 使用ASP.NET AJAX异步调用Web Service和页面中的类方法(10):服务器端和客户端数据类型的自动转换:以XML方式序列化数据、小结
- 序列化对象,使用的三种方式:Xml,Binary,Soap
- 服务器端和客户端数据类型的自动转换:以XML方式序列化数据
- 使用ASP.NET AJAX异步调用Web Service和页面中的类方法(10):服务器端和客户端数据类型的自动转换:以XML方式序列化数据、小结
- xml文件序列化方式
- 使用序列化的方式来读取XML配置文件
- Android中使用PULL方式解析XML和XmlSerializer进行序列化
- Android平台中实现对XML的三种解析方式(DOM 、PULL、 SAX)
- 转-springAOP基于XML配置文件方式
- 用序列化的方式保存简单的数据类型之积分查询系统的建设
- Spring学习之路第一步 : xml方式实现IOC(控制反转)
- java Redis Jedis存储Java对象 - (Java序列化为byte数组方式)
- 四种XML解析方式详解
- Java操作(DOM、SAX、JDOM、DOM4J)xml方式的四种比较与详解
- hibernate 联合主键生成机制(组合主键XML配置方式)
- xml文件--DOM方式解析xml