Skip to content

Instantly share code, notes, and snippets.

@eocron

eocron/SerializationHelpers.cs

Last active October 27, 2017 22:21
Show Gist options
  • Save eocron/50a5aae580779bf0b8bfd25924e96bc7 to your computer and use it in GitHub Desktop.
Save eocron/50a5aae580779bf0b8bfd25924e96bc7 to your computer and use it in GitHub Desktop.
Download ZIP
Just another JSON/XML serializer/deserializer on DataContract without external dependencies. Also have human-readable xml serializer.
Raw
SerializationHelpers.cs
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Xml;
namespace Helpers
{
public static class JsonHelper
{
public static string SerializeObject(object obj)
{
if (obj == null)
return String.Empty;
using (var ms = new MemoryStream())
{
var ser = new DataContractJsonSerializer(obj.GetType());
ser.WriteObject(ms, obj);
return Encoding.UTF8.GetString(ms.ToArray());
}
}
public static T DeserializeObject<T>(string json)
{
if (string.IsNullOrWhiteSpace(json))
return default(T);
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))
{
var ser = new DataContractJsonSerializer(typeof(T));
return (T) ser.ReadObject(ms);
}
}
}
public static class XmlHelper
{
private static readonly XmlWriterSettings DefaultW = new XmlWriterSettings
{
Indent = true,
NamespaceHandling = NamespaceHandling.OmitDuplicates,
};
private static readonly XmlReaderSettings DefaultR = new XmlReaderSettings();
public static string ReadableSerializeObject(object obj)
{
if (obj == null)
return String.Empty;
using (var ms = new MemoryStream())
{
using (var w = new SimplisticXmlWriter(XmlWriter.Create(ms, DefaultW)))
{
var ser = new DataContractSerializer(obj.GetType(), obj.GetType().Name, "");
ser.WriteObject(w, obj);
}
return Encoding.UTF8.GetString(ms.ToArray());
}
}
public static string SerializeObject(object obj, XmlWriterSettings settings = null)
{
if(obj == null)
return String.Empty;
settings = settings ?? DefaultW;
using (var ms = new MemoryStream())
{
using (var w = XmlWriter.Create(ms,settings))
{
var ser = new DataContractSerializer(obj.GetType());
ser.WriteObject(w, obj);
}
return Encoding.UTF8.GetString(ms.ToArray());
}
}
public static T DeserializeObject<T>(string xml, XmlReaderSettings settings = null)
{
if (string.IsNullOrWhiteSpace(xml))
return default(T);
settings = settings ?? DefaultR;
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
{
using (var w = XmlReader.Create(ms, settings))
{
var ser = new DataContractSerializer(typeof(T));
return (T) ser.ReadObject(w);
}
}
}
private sealed class SimplisticXmlWriter : XmlWriter
{
private readonly XmlWriter _inner;
public SimplisticXmlWriter(XmlWriter xmlWriterImplementation)
{
_inner = xmlWriterImplementation;
}
public override void WriteStartDocument()
{
_inner.WriteStartDocument();
}
public override void WriteStartDocument(bool standalone)
{
_inner.WriteStartDocument(standalone);
}
public override void WriteEndDocument()
{
_inner.WriteEndDocument();
}
public override void WriteDocType(string name, string pubid, string sysid, string subset)
{
_inner.WriteDocType(name, pubid, sysid, subset);
}
public override void WriteStartElement(string prefix, string localName, string ns)
{
_inner.WriteStartElement(null, localName, "");
}
public override void WriteEndElement()
{
_inner.WriteEndElement();
}
public override void WriteFullEndElement()
{
_inner.WriteFullEndElement();
}
private bool _ignoreXmlns = false;
public override void WriteStartAttribute(string prefix, string localName, string ns)
{
if (String.Compare(prefix, "xmlns", StringComparison.OrdinalIgnoreCase) == 0)
{
_ignoreXmlns = true;
return;
}
_inner.WriteStartAttribute(prefix, localName, ns);
}
public override void WriteEndAttribute()
{
if (_ignoreXmlns)
{
_ignoreXmlns = false;
return;
}
_inner.WriteEndAttribute();
}
public override void WriteCData(string text)
{
_inner.WriteCData(text);
}
public override void WriteComment(string text)
{
_inner.WriteComment(text);
}
public override void WriteProcessingInstruction(string name, string text)
{
_inner.WriteProcessingInstruction(name, text);
}
public override void WriteEntityRef(string name)
{
_inner.WriteEntityRef(name);
}
public override void WriteCharEntity(char ch)
{
_inner.WriteCharEntity(ch);
}
public override void WriteWhitespace(string ws)
{
_inner.WriteWhitespace(ws);
}
public override void WriteString(string text)
{
if(_ignoreXmlns)
return;
_inner.WriteString(text);
}
public override void WriteSurrogateCharEntity(char lowChar, char highChar)
{
_inner.WriteSurrogateCharEntity(lowChar, highChar);
}
public override void WriteChars(char[] buffer, int index, int count)
{
_inner.WriteChars(buffer, index, count);
}
public override void WriteRaw(char[] buffer, int index, int count)
{
_inner.WriteRaw(buffer, index, count);
}
public override void WriteRaw(string data)
{
_inner.WriteRaw(data);
}
public override void WriteBase64(byte[] buffer, int index, int count)
{
_inner.WriteBase64(buffer, index, count);
}
public override void Close()
{
_inner.Close();
}
public override void Flush()
{
_inner.Flush();
}
public override string LookupPrefix(string ns)
{
return "";
}
public override WriteState WriteState => _inner.WriteState;
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment