.NET序列化、反序列化，包含XML、JSON、二进制
（一、）序列化类：JSON用的反射调用；
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Xml.Serialization;
namespace CommonHelper
{
/// <summary>
/// 序列化操作类
/// Json、XML、二进制序列化反序列化
/// </summary>
public class SerializeConverter
{
#region JSON序列化
private static Type TypeJosnClass;
private static object objLock=new object();
/// <summary>
/// 序列化为JSON字符串
/// </summary>
/// <param name="obj">对象实体</param>
/// <returns></returns>
public static string SerializeObjectToJson(object obj)
{
try
{
MethodInfo mt = CreateJosnClass().GetMethod("SerializeObject", new Type[] { typeof(object) });
object[] param = new object[1] { obj };
object rt = mt.Invoke(null, param);
if (rt != null)
{
return rt.ToString();
}
else
{
return "";
}
}
catch(Exception ex)
{
Log.SaveExceptionLog("序列化为JSON字符串失败：", ex);
return "";
}
}
/// <summary>
/// 反序列化JSON为对象
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="json">JSON字符串</param>
/// <returns></returns>
public static T DeSerializeFromJson<T>(string json) where T : class
{
try
{
MethodInfo mt = CreateJosnClass().GetMethod("DeserializeObject", new Type[] { typeof(string), typeof(Type) });
object[] param = new object[2] { json, typeof(T) };
object rt = mt.Invoke(null, param);
if (rt == null)
{
return default(T);
}
else
{
return (T)rt;
}
}
catch (Exception ex)
{
Log.SaveExceptionLog("反序列化JSON为对象：", ex);
return null;
}
}
private static Type CreateJosnClass()
{
if (TypeJosnClass == null)
{
lock (objLock)
{
var tp = ReflexHelper.CreateClassType("Newtonsoft.Json.dll", "Newtonsoft.Json.JsonConvert");
TypeJosnClass = tp;
}
}
return TypeJosnClass;
}
#endregion JSON序列化
#region XML序列化
/// <summary>
/// XML反序列化
/// </summary>
public static T DeSerializeFromXML<T>(string strXML) where T : class
{
try
{
using (StringReader sr = new StringReader(strXML))
{
XmlSerializer serializer = new XmlSerializer(typeof(T));
return serializer.Deserialize(sr) as T;
}
}
catch (Exception ex)
{
Log.SaveExceptionLog("XML反序列化：", ex);
return null;
}
}
/// <summary>
/// XML序列化
/// 序列化的类必须标记为[[Serializable]]
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="obj">对象</param>
/// <returns></returns>
public static string SerializeObjectToXML<T>(T obj)
{
using (StringWriter sw = new StringWriter())
{
Type t = obj.GetType();
XmlSerializer serializer = new XmlSerializer(obj.GetType());
serializer.Serialize(sw, obj);
sw.Close();
return sw.ToString();
}
}
/// <summary>
/// XML序列化
/// 序列化的类必须标记为[[Serializable]]
/// </summary>
/// <param name="obj">对象</param>
/// <returns></returns>
public static string SerializeObjectToXML(object obj)
{
//using (StringWriter sw = new StringWriter())
//{
// Type t = obj.GetType();
// XmlSerializer serializer = new XmlSerializer(obj.GetType());
// serializer.Serialize(sw, obj);
// sw.Close();
// return sw.ToString();
//}
MemoryStream Stream = new MemoryStream();
XmlSerializer xml = new XmlSerializer(obj.GetType());
try
{
//序列化对象
xml.Serialize(Stream, obj);
}
catch (InvalidOperationException)
{
throw;
}
Stream.Position = 0;
StreamReader sr = new StreamReader(Stream);
string str = sr.ReadToEnd();
sr.Dispose();
Stream.Dispose();
return str;
}
#endregion XML序列化
#region 二进制序列化
/// <summary>
/// 二进制序列化
/// 序列化的类必须标记为[[Serializable]]
/// </summary>
/// <param name="request">对象实体</param>
/// <returns></returns>
public static byte[] SerializeObjectToBinary(object request)
{
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer =
new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
using (System.IO.MemoryStream memStream = new System.IO.MemoryStream())
{
serializer.Serialize(memStream, request);
return memStream.ToArray();
}
}
/// <summary>
/// 二进制反序列化
/// </summary>
/// <param name="data">二进制数据</param>
/// <returns></returns>
public static object DeSerializeFromBinary(byte[] data)
{
using (System.IO.MemoryStream memStream = new System.IO.MemoryStream(data))
{
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =
new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
return deserializer.Deserialize(memStream);
}
}
#endregion 二进制序列化
}
反射操作类：
/// <summary>
/// 反射调用类
/// 用于反射类型、属性、静态方法、实例方法等
/// </summary>
public class ReflexHelper
{
/// <summary>
/// 类型缓存
/// </summary>
public static Dictionary<string, Type> TypesCache = new Dictionary<string, Type>();
private static object Lockobj = new object();
#region 反射类型type、类calss
/// <summary>
/// 反射创建类型
/// </summary>
/// <param name="assmPath">dll程序集路径 XXX.dll widget\xxx.dll</param>
/// <param name="className">类名全称 Newtonsoft.Json.JsonConvert JHNIS.JHNISCommonLib.CommonHelper.ReflexHelper</param>
/// <returns></returns>
public static Type CreateClassType(string assmPath, string className)
{
string key = assmPath + "|" + className;
try
{
if (TypesCache.ContainsKey(key) == false)
{
lock (Lockobj)
{
var assm = Assembly.LoadFrom(GetBasePath() + assmPath);
var tp = assm.GetType(className);
if(tp==null)
{
Log.SaveLog("反射创建类型失败：" + GetBasePath() + assmPath + " class:"+ className);
}
TypesCache[key] = tp;
}
}
return TypesCache[key];
}
catch (Exception ex)
{
Log.SaveExceptionLog("反射创建类型失败：" + key, ex);
return null;
}
}
/// <summary>
/// 获取基本路径
/// 客户端，启动程序的根目录
/// WEB bin目录
/// </summary>
/// <returns></returns>
public static string GetBasePath()
{
string strPath = "";
if (System.Web.HttpContext.Current != null )
{
//web程序部署物理地址
strPath = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath + "\\bin\\";
}
else
{
//winform\WCF\exe\windows服务
strPath = System.AppDomain.CurrentDomain.BaseDirectory + "\\";
}
Log.SaveLog(string.Format("获取基本路径:base:{0} web:{1} log:{2}", System.AppDomain.CurrentDomain.BaseDirectory, System.Web.HttpContext.Current, JHNISCommonManage.GetInstance().Log.logPath));
return strPath;
}
/// <summary>
/// 反射类实体
/// </summary>
/// <param name="assmPath">dll程序集路径</param>
/// <param name="className">类名全称</param>
/// <returns></returns>
public static object CreateClassObject(string assmPath, string className)
{
try
{
Type type = CreateClassType(assmPath, className);
if (type == null)
{
return null;
}
object obj = Activator.CreateInstance(type);
if(obj==null)
{
Log.SaveLog("反射实体创建失败:assmPath "+ assmPath +" className:"+ className);
}
return obj;
}
catch (Exception ex)
{
Log.SaveExceptionLog("反射创建类失败：" + assmPath + " " + className, ex);
return null;
}
}
/// <summary>
/// 反射类实体
/// </summary>
/// <param name="assmPath">dll程序集路径</param>
/// <param name="className">类名全称</param>
/// <returns></returns>
public static T CreateClassObject<T>(string assmPath, string className)
{
object obj = CreateClassObject(assmPath, className);
if (obj != null)
{
return (T)obj;
}
else
{
return default(T);
}
}
#endregion 反射类型type、类calss
#region 反射调用-静态方法
/// <summary>
/// 反射类的静态方法
/// </summary>
/// <param name="assmPath">dll程序集路径 XXX.dll widget\xxx.dll</param>
/// <param name="className">类名全称 Newtonsoft.Json.JsonConvert JHNIS.JHNISCommonLib.CommonHelper.ReflexHelper</param>
/// <param name="methodName">方法名</param>
/// <param name="paramValues">参数列表</param>
/// <returns></returns>
public static object ExcuteStaticMethod(string assmPath, string className, string methodName, object[] paramValues)
{
return ExcuteStaticMethod(assmPath, className, methodName, paramValues, null);
}
/// <summary>
/// 反射类的静态方法（带参数类型）
/// 重载方法，需要传参数类型来确定是哪个重载
/// </summary>
/// <param name="assmPath">dll程序集路径 XXX.dll widget\xxx.dll</param>
/// <param name="className">类名全称 Newtonsoft.Json.JsonConvert JHNIS.JHNISCommonLib.CommonHelper.ReflexHelper</param>
/// <param name="methodName">方法名</param>
/// <param name="paramValues">参数列表</param>
/// <param name="paramTypes">参数类型列表，重载方法，需要传参数类型来确定是哪个重载</param>
/// <returns></returns>
public static object ExcuteStaticMethod(string assmPath, string className, string methodName, object[] paramValues, Type[] paramTypes)
{
Type type = CreateClassType(assmPath, className);
if (type == null)
{
JHNISCommonManage.GetInstance().Log.SaveLog(string.Format("反射方法Type失败：dll:{0} class:{1} method:{2}", assmPath, className, methodName));
return null;
}
return ExcuteStaticMethod(type, methodName, paramValues, paramTypes);
}
/// <summary>
/// 反射类的静态方法
/// </summary>
/// <param name="type">类型</param>
/// <param name="methodName">方法名</param>
/// <param name="paramValues">参数列表</param>
/// <param name="paramTypes">参数类型列表 重载方法，需要传参数类型来确定是哪个重载 无重载的传null</param>
/// <returns></returns>
public static object ExcuteStaticMethod(Type type, string methodName, object[] paramValues, Type[] paramTypes)
{
string assmPath = type.Assembly.FullName;
string className = type.FullName;
try
{
MethodInfo mt;
if (paramTypes != null)
{
mt = type.GetMethod(methodName, paramTypes);
}
else
{
mt = type.GetMethod(methodName);
}
object rt = mt.Invoke(null, paramValues);
return rt;
}
catch (Exception ex)
{
JHNISCommonManage.GetInstance().Log.SaveExceptionLog(string.Format("反射Static方法失败：dll:{0} class:{1} method:{2}", assmPath, className, methodName), ex);
return null;
}
}
#endregion 反射调用-静态方法
#region 反射调用-实例方法
/// <summary>
/// 反射实体方法
/// </summary>
/// <param name="obj">类实例</param>
/// <param name="methodName"></param>
/// <param name="paramValues"></param>
/// <returns></returns>
public static object ExecuteObjectMethod(object obj,string methodName,object[] paramValues)
{
return ExecuteObjectMethod(obj, methodName, paramValues, null);
}
/// <summary>
/// 反射实体方法（重载方法）
/// </summary>
/// <param name="obj">类实例</param>
/// <param name="methodName"></param>
/// <param name="paramValues"></param>
/// <param name="paramTypes">参数类型列表 重载方法，需要传参数类型来确定是哪个重载 无重载的传null</param>
/// <returns></returns>
public static object ExecuteObjectMethod(object obj, string methodName, object[] paramValues,Type[] paramTypes)
{
try
{
if(obj==null)
{
Log.SaveLog("反射实体方法失败：实体创建失败 = null 方法名:"+methodName);
return null;
}
MethodInfo mt=null;
try
{
if (paramTypes != null)
{
mt = obj.GetType().GetMethod(methodName, paramTypes);
if (mt == null)
{
mt = obj.GetType().GetMethod(methodName);
}
}
else
{
mt = obj.GetType().GetMethod(methodName);
}
}
catch (Exception ex)
{
Log.SaveExceptionLog(string.Format("反射实体方法失败 GetMethod：class:{0} method:{1}", obj.GetType().FullName, methodName), ex);
}
if (mt == null)
{
foreach (MethodInfo m in obj.GetType().GetMethods())
{
//JHNISCommonManage.GetInstance().Log.SaveLog("类：" + obj.GetType().FullName + " 方法：" + methodName);
if (m.Name == methodName)
{
mt = m;
}
}
if(mt==null)
{
throw new Exception("找不到方法：类：" + obj.GetType().FullName +" 方法："+ methodName);
}
}
object rt = mt.Invoke(obj, paramValues);
return rt;
}
catch (Exception ex)
{
Log.SaveExceptionLog(string.Format("反射实体方法失败 Exception：class:{0} method:{1}", obj.GetType().FullName, methodName), ex);
return null;
}
}
#endregion 反射调用-实例方法
#region 反射属性-静态
/// <summary>
/// 获取-静态类属性
/// </summary>
/// <param name="assmPath"></param>
/// <param name="className"></param>
/// <param name="pName"></param>
/// <returns></returns>
public static object GetStaticPropertyValue(string assmPath, string className, string pName)
{
Type type = CreateClassType(assmPath, className);
if (type != null)
{
return GetStaticPropertyValue(type, pName);
}
else
{
return null;
}
}
/// <summary>
/// 获取-静态类属性
/// </summary>
/// <param name="type"></param>
/// <param name="pName"></param>
/// <returns></returns>
public static object GetStaticPropertyValue(Type type, string pName)
{
PropertyInfo p = type.GetProperty(pName);
if (p == null)
{
//日志
Log.SaveLog("反射获取-静态属性失败：" + type + " 属性:" + pName);
return null;
}
else
{
return p.GetValue(null, null);
}
}
/// <summary>
/// 设置-静态类属性
/// </summary>
/// <param name="assmPath"></param>
/// <param name="className"></param>
/// <param name="pName"></param>
/// <param name="vl"></param>
public static void SetStaticPropertyValue(string assmPath, string className, string pName, object vl)
{
Type type = CreateClassType(assmPath, className);
if (type != null)
{
SetStaticPropertyValue(type, pName, vl);
}
}
/// <summary>
/// 设置-静态类属性
/// </summary>
/// <param name="type"></param>
/// <param name="pName"></param>
/// <param name="vl"></param>
public static void SetStaticPropertyValue(Type type, string pName, object vl)
{
PropertyInfo p = type.GetProperty(pName);
if (p == null)
{
//日志
Log.SaveLog("反射设置-静态属性失败：" + type + " 属性:" + pName);
}
else if (p.PropertyType != vl.GetType())
{
//日志
Log.SaveLog("反射设置-静态属性失败-属性值类型不符：" + type + " 属性:" + pName + " 属性类型:" + vl.GetType());
}
else
{
p.SetValue(null, vl, null);
}
}
#endregion 反射属性-静态
#region 反射属性-实例
/// <summary>
/// 获取-实例类属性
/// </summary>
/// <param name="obj">类实例</param>
/// <param name="pName">属性名称</param>
/// <returns></returns>
public static object GetObjectPropertyValue(object obj,string pName)
{
PropertyInfo p = obj.GetType().GetProperty(pName);
if(p==null)
{
var finfo = obj.GetType().GetField(pName);
if(finfo==null)
{
//日志
Log.SaveLog("反射获取实例属性失败,无此属性/字段：" + obj.GetType() + " 属性:" + pName);
return null;
}
else
{
return finfo.GetValue(obj);
}
}
else
{
return p.GetValue(obj, null);
}
}
/// <summary>
/// 设置-实例类属性
/// </summary>
/// <param name="obj">类实例</param>
/// <param name="pName">属性名称</param>
/// <param name="vl">属性值</param>
public static void SetObjectPropertyValue(object obj, string pName, object vl)
{
PropertyInfo p = obj.GetType().GetProperty(pName);
if (p == null)
{
//日志
Log.SaveLog("反射设置实例属性失败：" + obj.GetType() + " 属性:" + pName);
}
else if(p.PropertyType != vl.GetType())
{
//日志
Log.SaveLog("反射设置实例属性失败-属性值类型不符：" + obj.GetType() + " 属性:" + pName+ " 属性类型:" + vl.GetType());
}
else
{
p.SetValue(obj, vl, null);
}
}
#endregion 反射属性-实例
}
}
