Extension Methods – Serialize/Deserialize as Json/XML

Yan Cui

I help clients go faster for less using serverless technologies.

   1: public static class SerializationExtensions

   2: {

   3:     private static readonly ConcurrentDictionary<Type, XmlSerializer> XmlSerializers =

   4:         new ConcurrentDictionary<Type, XmlSerializer>();

   5:

   6:     private static readonly ConcurrentDictionary<Type, DataContractJsonSerializer> JsonSerializers =

   7:         new ConcurrentDictionary<Type, DataContractJsonSerializer>();

   8:

   9:     private static readonly JavaScriptSerializer JavaScriptSerializer = new JavaScriptSerializer();

  10:

  11:     public enum JsonSerializerType

  12:     {

  13:         Undefined = 0,

  14:

  15:         DataContractJsonSerializer = 1,

  16:

  17:         JavaScriptSerializer = 2

  18:     }

  19:

  20:     /// <summary>

  21:     /// Serializes the object using XML format.

  22:     /// </summary>

  23:     public static string SerializeAsXml(this object obj)

  24:     {

  25:         var type = obj.GetType();

  26:         var xmlSerializer = GetXmlSerializer(type);

  27:

  28:         using (var memStream = new MemoryStream())

  29:         {

  30:             xmlSerializer.Serialize(memStream, obj);

  31:             return Encoding.Default.GetString(memStream.ToArray());

  32:         }

  33:     }

  34:

  35:     /// <summary>

  36:     /// Serializes the object using JSON format, either using the default 

  37:     /// DataContractJsonSerializer or the JavaScriptSerializer, the results

  38:     /// differ slightly.

  39:     /// </summary>

  40:     public static string SerializeAsJson(

  41:         this object obj,

  42:         JsonSerializerType serializerType = JsonSerializerType.DataContractJsonSerializer)

  43:     {

  44:         switch (serializerType)

  45:         {

  46:             case JsonSerializerType.JavaScriptSerializer:

  47:                 return JavaScriptSerializer.Serialize(obj);

  48:             case JsonSerializerType.DataContractJsonSerializer:

  49:             default:

  50:                 var type = obj.GetType();

  51:                 var serializer = GetJsonSerializer(type);

  52:

  53:                 using (var memStream = new MemoryStream())

  54:                 {

  55:                     serializer.WriteObject(memStream, obj);

  56:                     return Encoding.Default.GetString(memStream.ToArray());

  57:                 }

  58:         }

  59:     }

  60:

  61:     /// <summary>

  62:     /// Deserializes the specified XML string to an object of the specified type T.

  63:     /// </summary>

  64:     public static T DeserializeAsXml<T>(this string xmlString)

  65:     {

  66:         var xmlSerializer = GetXmlSerializer(typeof(T));

  67:         using (var memStream = new MemoryStream(Encoding.Default.GetBytes(xmlString)))

  68:         {

  69:             return (T)xmlSerializer.Deserialize(memStream);

  70:         }

  71:     }

  72:

  73:     /// <summary>

  74:     /// Deserializes the specified JSON string to an object of the specified type T.

  75:     /// </summary>

  76:     public static T DeserializeAsJson<T>(

  77:         this string jsonString,

  78:         JsonSerializerType serializerType = JsonSerializerType.DataContractJsonSerializer)

  79:     {

  80:         switch (serializerType)

  81:         {

  82:             case JsonSerializerType.JavaScriptSerializer:

  83:                 return JavaScriptSerializer.Deserialize<T>(jsonString);

  84:             case JsonSerializerType.DataContractJsonSerializer:

  85:             default:

  86:                 var serializer = GetJsonSerializer(typeof(T));

  87:

  88:                 using (var memStream = new MemoryStream(Encoding.Default.GetBytes(jsonString)))

  89:                 {

  90:                     return (T)serializer.ReadObject(memStream);

  91:                 }

  92:         }

  93:     }

  94:

  95:     private static XmlSerializer GetXmlSerializer(Type type)

  96:     {

  97:         // gets the xml serializer from the concurrent dictionary, if it doesn't exist

  98:         // then add one for the specified type

  99:         return XmlSerializers.GetOrAdd(type, t => new XmlSerializer(t));

 100:     }

 101:

 102:     private static DataContractJsonSerializer GetJsonSerializer(Type type)

 103:     {

 104:         // gets the json serializer from the concurrent dictionary, if it doesn't exist

 105:         // then add one for the specified type

 106:         return JsonSerializers.GetOrAdd(type, t => new DataContractJsonSerializer(t));

 107:     }

 108: }