JSON serialized object in NHibernate

The other day I needed to store some user settings into the database. The settings involved the properties of a chart, with title, axis, series, manual series etc. Normally there would be a entity for the chart, entities for the series with some kind of inheritance and then create all the mappings.

A lot of overhead for storing some settings, in case of a NoSQL database like MongoDB you just save the settings object.

I thought it would be nice to just map the settings object as a single column like:

 Property(p => p.Settings);

Therefore I developed a  JSONMappableType for NHibernate:

Property(p => p.Settings, m =>

        {

            m.Length(8096);

          m.Type<JsonMappableType<Settings>>();

        });

This serializes the complete Settings object to a JSON-string into a single column. And when retrieving from the database the Settings object is deserialized from the JSON-string.

I derived the mapping from NHibernates IUserType and used Newtonsoft.Json for the (de-)serialisation of the object. I had to override the DefaultContractResolver, because the order of the properties is random at each call which made object 'dirty' all the time. Ordering the properties by name solved that problem.

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

using NHibernate;

using NHibernate.SqlTypes;

using NHibernate.UserTypes;

using System;

using System.Linq;

namespace My.Mappings

{

    public class JsonMappableType<T> :IUserType

    {

        public object Assemble(object cached, object owner)

        {

            //Used for casching, as our object is immutable we can just return it as is

            return cached;

        }

        public object DeepCopy(object value)

        {

            //We deep copy the Translation by creating a new instance with the same contents

            if (value == null)

                return null;

            if (value.GetType() != typeof(T))

                return null;

            return FromJson(ToJson((T)value));

        }

        

       

        public object Disassemble(object value)

        {

            //Used for casching, as our object is immutable we can just return it as is

            return value;

        }

        public new bool Equals(object x, object y)

        {

            //Use json-query-string to see if their equal 

            // on value so we use this implementation

            if (x == null || y == null)

                return false;

            if (x.GetType() != typeof(T) || y.GetType() != typeof(T))

                return false;

            return ToJson((T)x).Equals(ToJson((T)y));

        }

        public int GetHashCode(object x)

        {

            if (x != null && x.GetType() == typeof(T))

                return ToJson((T)x).GetHashCode();

            return x.GetHashCode();

        }

        public bool IsMutable

        {

            get { return false; }

        }

        public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)

        {

            //We get the string from the database using the NullSafeGet used to get strings 

            string jsonString = (string)NHibernateUtil.String.NullSafeGet(rs, names[0]);

            //And save it in the T object. This would be the place to make sure that your string 

            //is valid for use with the T class

            return FromJson(jsonString);

        }

        public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)

        {

            //Set the value using the NullSafeSet implementation for string from NHibernateUtil

            if (value == null)

            {

                NHibernateUtil.String.NullSafeSet(cmd, null, index);

                return;

            }

            value = ToJson((T)value);

            NHibernateUtil.String.NullSafeSet(cmd, value, index);

        }

        public object Replace(object original, object target, object owner)

        {

            //As our object is immutable we can just return the original

            return original;

        }

        public Type ReturnedType

        {

            get { return typeof(T); }

        }

        public SqlType[] SqlTypes

        {

            get

            {

                //We store our translation in a single column in the database that can contain a string

                SqlType[] types = new SqlType[1];

                types[0] = new SqlType(System.Data.DbType.String);

                return types;

            }

        }

        private static JsonSerializerSettings jsonSetting = new JsonSerializerSettings

        {

            ContractResolver = new OrderedContractResolver(),

            Formatting = Formatting.None,

            ReferenceLoopHandling = ReferenceLoopHandling.Ignore,

            PreserveReferencesHandling = PreserveReferencesHandling.Objects,

            DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate

            

        };

        public static T FromJson(string jsonString)

        {

            if (!string.IsNullOrWhiteSpace(jsonString))

                return JsonConvert.DeserializeObject<T>(jsonString, jsonSetting);

            return Activator.CreateInstance<T>();

        }

        public static string ToJson(T obj)

        {

            return JsonConvert.SerializeObject(obj, jsonSetting);

        }

        /// <summary>

        /// Order the json-properties to create a simple equals case for JsonMappableType.Equals

        /// </summary>

        private class OrderedContractResolver : DefaultContractResolver

        {

            protected override System.Collections.Generic.IList<JsonProperty> CreateProperties(System.Type type, MemberSerialization memberSerialization)

            {

                return base.CreateProperties(type, memberSerialization).OrderBy(p => p.PropertyName).ToList();

            }

        }

    }

}