一个技术汪的开源梦 —— 基于 .Net Core 的公共组件之序列化

一个技术汪的开源梦 —— 目录

想必大家在项目中都接触过 JSON 或者 XML 吧，为了将对象在网络上传输或者将其持久化必须将其序列化为一个字符串然后进行后续操作。常见的就是将其序列化成 JSON 或者 XML 。

大家在项目中应该都看到过这样的工具类 例如 ***XmlHelper、***JsonHelper 等，没错这一些助手类会帮助我们重复造*。既然是组件并且还是是开源的必须考虑每个功能的后续可扩展性以及易用性。

ISerializer 序列化者接口

 using System;

 namespace Wlitsoft.Framework.Common.Abstractions.Serialize
 {
     /// <summary>
     /// 序列化者接口。
     /// </summary>
     public interface ISerializer
     {
         /// <summary>
         /// 获取序列化类型。
         /// </summary>
         SerializeType SerializeType { get; }

         /// <summary>
         /// 将一个对象序列化成一个字符串。
         /// </summary>
         /// <param name="obj">要序列化的对象。</param>
         /// <returns>序列化后的字符串。</returns>
         string Serialize(object obj);

         /// <summary>
         /// 将一个字符串反序列化为一个对象。
         /// </summary>
         /// <param name="objType">要反序序列化的对象类型。</param>
         /// <param name="str">要反序列化的字符串。</param>
         /// <returns>反序列化得到的对象。</returns>
         object Deserialize(Type objType, string str);

         /// <summary>
         /// 将一个字符串反序列化为一个对象。
         /// </summary>
         /// <param name="str">要反序列化的字符串。</param>
         /// <returns>反序列化得到的对象。</returns>
         T Deserialize<T>(string str);
     }
 }

该接口很简单就一个属性标示序列化类型、序列化方法、反序列化方法。

SerializeType 序列化类型

 namespace Wlitsoft.Framework.Common.Abstractions.Serialize
 {
     /// <summary>
     /// 序列化类型。
     /// </summary>
     public enum SerializeType
     {
         /// <summary>
         /// Xml。
         /// </summary>
         Xml,

         /// <summary>
         /// Json。
         /// </summary>
         Json
     }
 }

一个枚举标识使用哪种序列化方式。

类型有了那对应的原始的实现肯定少不了。

- JsonSerializer Json 序列化/反序列化。

 using System;
 using System.IO;
 using System.Runtime.Serialization.Json;
 using System.Text;
 using Wlitsoft.Framework.Common.Abstractions.Serialize;
 using Wlitsoft.Framework.Common.Exception;

 namespace Wlitsoft.Framework.Common.Serialize
 {
     /// <summary>
     /// Json 序列化/反序列化。
     /// </summary>
     public class JsonSerializer : ISerializer
     {
         #region ISerializer 成员

         /// <summary>
         /// 获取序列化类型。
         /// </summary>
         public SerializeType SerializeType { get; } = SerializeType.Json;

         /// <summary>
         /// 将一个对象序列化成一个字符串。
         /// </summary>
         /// <param name="obj">要序列化的对象。</param>
         /// <returns>序列化后的字符串。</returns>
         public string Serialize(object obj)
         {
             #region  参数校验

             if (obj == null)
                 throw new ObjectNullException(nameof(obj));

             #endregion

             using (var ms = new MemoryStream())
             {
                 new DataContractJsonSerializer(obj.GetType()).WriteObject(ms, obj);
                 return Encoding.UTF8.GetString(ms.ToArray());
             }

         }

         /// <summary>
         /// 将一个字符串反序列化为一个对象。
         /// </summary>
         /// <param name="objType">要反序序列化的对象类型。</param>
         /// <param name="str">要反序列化的字符串。</param>
         /// <returns>反序列化得到的对象。</returns>
         public object Deserialize(Type objType, string str)
         {
             #region 参数校验

             if (objType == null)
                 throw new ObjectNullException(nameof(objType));

             if (string.IsNullOrEmpty(str))
                 throw new StringNullOrEmptyException(nameof(str));

             #endregion

             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(str)))
             {
                 return new DataContractJsonSerializer(objType).ReadObject(ms);
             }
         }

         /// <summary>
         /// 将一个字符串反序列化为一个对象。
         /// </summary>
         /// <param name="str">要反序列化的字符串。</param>
         /// <returns>反序列化得到的对象。</returns>
         public T Deserialize<T>(string str)
         {
             #region 参数校验

             if (string.IsNullOrEmpty(str))
                 throw new StringNullOrEmptyException(nameof(str));

             #endregion

             return (T)this.Deserialize(typeof(T), str);
         }

         #endregion
     }
 }

JsonSerializer

- XmlSerializer Xml 序列化/反序列化。

 using System;
 using System.IO;
 using System.Text;
 using System.Xml;
 using System.Xml.Serialization;
 using Wlitsoft.Framework.Common.Abstractions.Serialize;
 using Wlitsoft.Framework.Common.Exception;

 namespace Wlitsoft.Framework.Common.Serialize
 {
     /// <summary>
     /// Xml 序列化/反序列化。
     /// </summary>
     public class XmlSerializer : ISerializer
     {
         #region ISerializer 成员

         /// <summary>
         /// 获取序列化类型。
         /// </summary>
         public SerializeType SerializeType { get; } = SerializeType.Xml;

         /// <summary>
         /// 将一个对象序列化成一个字符串。
         /// </summary>
         /// <param name="obj">要序列化的对象。</param>
         /// <returns>序列化后的字符串。</returns>
         public string Serialize(object obj)
         {
             #region  参数校验

             if (obj == null)
                 throw new ObjectNullException(nameof(obj));

             #endregion

             System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType());

             //去除默认的命名空间声明。
             XmlSerializerNamespaces xmlNamespaces = new XmlSerializerNamespaces();
             xmlNamespaces.Add("", "");

             XmlWriterSettings settings = new XmlWriterSettings();
             settings.OmitXmlDeclaration = true;
             settings.Indent = true;
             settings.NewLineChars = "\r\n";
             settings.IndentChars = "    ";

             MemoryStream outStream = new MemoryStream();
             using (XmlWriter writer = XmlWriter.Create(outStream, settings))
             {
                 serializer.Serialize(writer, obj, xmlNamespaces);
             }

             outStream.Position = ;
             using (StreamReader reader = new StreamReader(outStream))
             {
                 return reader.ReadToEnd();
             }
         }

         /// <summary>
         /// 将一个字符串反序列化为一个对象。
         /// </summary>
         /// <param name="objType">要反序序列化的对象类型。</param>
         /// <param name="str">要反序列化的字符串。</param>
         /// <returns>反序列化得到的对象。</returns>
         public object Deserialize(Type objType, string str)
         {
             #region 参数校验

             if (objType == null)
                 throw new ObjectNullException(nameof(objType));

             if (string.IsNullOrEmpty(str))
                 throw new StringNullOrEmptyException(nameof(str));

             #endregion

             System.Xml.Serialization.XmlSerializer mySerializer = new System.Xml.Serialization.XmlSerializer(objType);
             using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(str)))
             {
                 using (StreamReader sr = new StreamReader(ms))
                 {
                     return mySerializer.Deserialize(sr);
                 }
             }
         }

         /// <summary>
         /// 将一个字符串反序列化为一个对象。
         /// </summary>
         /// <param name="str">要反序列化的字符串。</param>
         /// <returns>反序列化得到的对象。</returns>
         public T Deserialize<T>(string str)
         {
             #region 参数校验

             if (string.IsNullOrEmpty(str))
                 throw new StringNullOrEmptyException(nameof(str));

             #endregion

             return (T)this.Deserialize(typeof(T), str);
         }

         #endregion

     }
 }

XmlSerializer

接口有了，对应的原生实现也有了，那咋用呢，还有我要不想用原生的Json 序列化方式咋办比如想用 JSON.Net 别急继续往下 See。

SerializerFactory 序列化工厂

把它定义成工厂确实有些牵强但是没有想到很好的名称 那就暂时先就叫工厂吧。它主要存储所有的序列化者对象实例、可以获取实例、亦可以重新设置实例。下面只列出方法签名。

/// <summary>
/// 获取一个 <see cref="ISerializer"/> 的实例。
/// </summary>
/// <param name="type">序列化类型。</param>
/// <returns>一个 <see cref="ISerializer"/> 类型的对象实例。</returns>
public ISerializer GetSerializer(SerializeType type)

/// <summary>
/// 获取一个 <see cref="ISerializer"/> 的实例。
/// </summary>
/// <param name="type">序列化类型。</param>
/// <returns>一个 <see cref="ISerializer"/> 类型的对象实例。</returns>
public ISerializer GetSerializer(SerializeType type)

现在可以使用了，等下 还没完。。。 为了更便于使用它们 将其做成 扩展方法。

ObjectExtensions 对象扩展方法静态类。

 /// <summary>
 /// 将 json 字符串转换为指定类型的对象表示形式。
 /// </summary>
 /// <typeparam name="T">要转换成的对象类型。</typeparam>
 /// <param name="json">json 字符串。</param>
 /// <returns>转换完后的 JSON 对象。</returns>
 public static T ToJsonObject<T>(this string json)
 {
     #region 参数校验

     if (string.IsNullOrEmpty(json))
         throw new StringNullOrEmptyException(nameof(json));

     #endregion

     ISerializer serializer = GlobalConfig.SerializerFactory.GetJsonSerializer();
     return serializer.Deserialize<T>(json);
 }

 /// <summary>
 /// 将给定 XML 字符串（<see paracref="xml"/>）转换为指定类型的对象表示形式。
 /// </summary>
 /// <typeparam name="T">要转换成的对象类型。</typeparam>
 /// <param name="xml">json 字符串。</param>
 /// <returns>转换完后的 Xml 对象。</returns>
 public static T ToXmlObject<T>(this string xml)
 {
     #region 参数校验

     if (string.IsNullOrEmpty(xml))
         throw new StringNullOrEmptyException(nameof(xml));

     #endregion

     ISerializer serializer = GlobalConfig.SerializerFactory.GetXmlSerializer();
     return serializer.Deserialize<T>(xml);
 }

StringExtensions 字符串类型扩展方法静态类。

 /// <summary>
 /// 将给定对象(<paramref name="obj"/>)转换成 JSON 字符串的表示形式。
 /// </summary>
 /// <param name="obj">准备进行转换的对象。</param>
 /// <returns>转换后生成的 JSON 字符串。</returns>
 public static string ToJsonString(this object obj)
 {
     #region 参数校验

     if (obj == null)
         throw new ObjectNullException(nameof(obj));

     #endregion

     ISerializer serializer = GlobalConfig.SerializerFactory.GetJsonSerializer();
     return serializer.Serialize(obj);
 }

 /// <summary>
 /// 将给定 XML 字符串（<see paracref="xml"/>）转换为指定类型的对象表示形式。
 /// </summary>
 /// <typeparam name="T">要转换成的对象类型。</typeparam>
 /// <param name="xml">json 字符串。</param>
 /// <returns>转换完后的 Xml 对象。</returns>
 public static T ToXmlObject<T>(this string xml)
 {
     #region 参数校验

     if (string.IsNullOrEmpty(xml))
         throw new StringNullOrEmptyException(nameof(xml));

     #endregion

     ISerializer serializer = GlobalConfig.SerializerFactory.GetXmlSerializer();
     return serializer.Deserialize<T>(xml);
 }

关于扩展性

回到刚才那个问题，如果我不想用原生的 Json 序列化方式咋办，难不成字符串扩展以及对象扩展这些方法都用不了了吗。别急继续往下看。

Common.JsonNet.JsonSerializer 公共类库 Json.Net 组件序列化者。

该项目中  JsonNetJsonSerializer  实现了  ISerializer 接口，也就是说这个类有序列化和反序列化的能力，那类有了怎么用呢。

当然你可以直接 new 一个 JsonNetJsonSerializer 的实例 然后使用。但是这样的话就有点本末倒置了。

GlobalConfig 全局配置静态类

这个类中后续会有好多属性 可以修改 Common 包内部的一些实现方式。

比如：将 Common 包中原生的 Json 序列化实现用 JSON.Net 取缔只需要 在 网站的 Startup 或者 控制台中的 静态构造方法中写入下面一行代码即可。

 GlobalConfig.SerializerFactory.SetSerializer(SerializeType.Json,new JsonNetJsonSerializer());

一个技术汪的开源梦 —— 目录