public static class SerializeHelpers
    {
        /// <summary> 
        /// Takes an array of bytes and attempts to deserialize it into an object. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <returns></returns> 
        public static T DeserializeFromByteArray<T>(byte[] source) where T : class
        {
            return DeserializeFromByteArray<T>(source, s => { }, r => { });
        }

        /// <summary> 
        /// Takes an array of bytes and attempts to deserialize it into an object. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <param name="deserializingAction"></param>
        /// <param name="deserializedAction"></param>
        /// <returns></returns> 
        public static T DeserializeFromByteArray<T>(byte[] source, Action<byte[]> deserializingAction, Action<T> deserializedAction) where T : class
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (source.Length <= 0)
                throw new ArgumentException("Can not deserialize from an empty byte array!", "source");
            if (deserializingAction == null)
                throw new ArgumentNullException("deserializingAction");
            if (deserializedAction == null)
                throw new ArgumentNullException("deserializedAction");

            deserializingAction(source);

            var ms = new MemoryStream();
            ms.Write(source, 0, source.Length);
            ms.Seek(0, SeekOrigin.Begin);
            var b = new BinaryFormatter();
            var result = (T)b.Deserialize(ms);

            deserializedAction(result);

            return result;
        }

        /// <summary> 
        /// Takes any object and attempts to serialize it into an array of bytes. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <returns></returns> 
        /// <remarks></remarks> 
        public static byte[] SerializeToByteArray<T>(T source) where T : class
        {
            return SerializeToByteArray<T>(source, s => { }, r => { });
        }

        /// <summary> 
        /// Takes any object and attempts to serialize it into an array of bytes. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <param name="serializingAction"></param>
        /// <param name="serializedAction"></param>
        /// <returns></returns> 
        /// <remarks></remarks> 
        public static byte[] SerializeToByteArray<T>(T source, Action<T> serializingAction, Action<byte[]> serializedAction) where T : class
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (serializingAction == null)
                throw new ArgumentNullException("serializingAction");
            if (serializedAction == null)
                throw new ArgumentNullException("serializedAction");

            serializingAction(source);

            var b = new BinaryFormatter();
            var ms = new MemoryStream();
            b.Serialize(ms, source);
            ms.Seek(0, SeekOrigin.Begin);
            var result = ms.ToArray();

            serializedAction(result);

            return result;
        }

        /// <summary> 
        /// Takes any object and attempts to serialize it into a string. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <returns></returns> 
        /// <remarks></remarks> 
        public static string SerializeToString<T>(T source) where T : class
        {
            return SerializeToString(source, s => { }, r => { });
        }

        /// <summary> 
        /// Takes any object and attempts to serialize it into a string. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <param name="serializingAction"></param>
        /// <param name="serializedAction"></param>
        /// <returns></returns> 
        /// <remarks></remarks> 
        public static string SerializeToString<T>(T source, Action<T> serializingAction, Action<string> serializedAction) where T : class
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (serializingAction == null)
                throw new ArgumentNullException("serializingAction");
            if (serializedAction == null)
                throw new ArgumentNullException("serializedAction");

            serializingAction(source);

            string serialString = null;
            using (var ms1 = new System.IO.MemoryStream())
            {
                var b = new BinaryFormatter();
                b.Serialize(ms1, source);
                var arrayByte = ms1.ToArray();
                serialString = Convert.ToBase64String(arrayByte);
            }

            serializedAction(serialString);

            return serialString;
        }

        /// <summary> 
        /// Takes a string and attempts to deserialize it into an object. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <returns></returns> 
        public static T DeserializeFromString<T>(string source) where T : class
        {
            return DeserializeFromString<T>(source, s => { }, r => { });
        }

        /// <summary> 
        /// Takes a string and attempts to deserialize it into an object. 
        /// </summary> 
        /// <param name="source"></param> 
        /// <param name="deserializingAction"></param>
        /// <param name="deserializedAction"></param>
        /// <returns></returns> 
        public static T DeserializeFromString<T>(string source, Action<string> deserializingAction, Action<T> deserializedAction) where T : class
        {
            if (string.IsNullOrEmpty(source))
                throw new ArgumentNullException("source");
            if (source.Length <= 0)
                throw new ArgumentException("Can not deserialize from an empty byte array!", "source");
            if (deserializingAction == null)
                throw new ArgumentNullException("deserializingAction");
            if (deserializedAction == null)
                throw new ArgumentNullException("deserializedAction");

            deserializingAction(source);

            T deserializedObject = null;
            var arrayByte = Convert.FromBase64String(source);
            using (var ms1 = new MemoryStream(arrayByte))
            {
                var b = new BinaryFormatter();
                deserializedObject = (T)b.Deserialize(ms1);
            }

            deserializedAction(deserializedObject);

            return deserializedObject;
        }

        public static string SerializeToXml(object source)
        {
            return SerializeToXml(false);
        }

        public static string SerializeToXml(object source, bool omitXmlDeclaration)
        {
            var xmlString = new StringBuilder();
            var xmlSettings = new XmlWriterSettings
                                  {
                                      Encoding = new UTF8Encoding(),
                                      OmitXmlDeclaration = omitXmlDeclaration
                                  };
            var xmlWriter = XmlWriter.Create(xmlString, xmlSettings);
            var serializer = new XmlSerializer(source.GetType());

            if (xmlWriter != null)
            {
                serializer.Serialize(xmlWriter, source);
                xmlWriter.Close();                
            }

            return xmlString.ToString();
        }

        public static T DeserializeFromXml<T>(string source) where T : class
        {
            var serializer = new XmlSerializer(typeof(T));
            var reader = new StringReader(source);
            T result = (T) serializer.Deserialize(reader);
            reader.Dispose();
            return result;
        }
    }