Add WCF-style Serialization Hook with JsConfig<T>.OnSerializeFn

Author: mythz

src/ServiceStack.Text/Common/JsWriter.cs

@@ -262,18 +262,36 @@ public WriteObjectDelegate GetWriteFn<T>()
                 return Serializer.WriteObjectString;
             }
 
+            WriteObjectDelegate ret = null;
+
             var onSerializingFn = JsConfig<T>.OnSerializingFn;
             if (onSerializingFn != null)
             {
-                return (w, x) => GetCoreWriteFn<T>()(w, onSerializingFn((T)x));
+                ret = (w, x) => GetCoreWriteFn<T>()(w, onSerializingFn((T)x));
             }
 
             if (JsConfig<T>.HasSerializeFn)
             {
-                return JsConfig<T>.WriteFn<TSerializer>;
+                ret = JsConfig<T>.WriteFn<TSerializer>;
+            }
+
+            if (ret == null)
+            {
+                ret = GetCoreWriteFn<T>();
+            }
+
+            var onSerializedFn = JsConfig<T>.OnSerializedFn;
+            if (onSerializedFn != null)
+            {
+                var writerFunc = ret;
+                ret = (w, x) =>
+                {
+                    writerFunc(w, x);
+                    onSerializedFn((T)x);
+                };
             }
 
-            return GetCoreWriteFn<T>();
+            return ret;
         }
 
         public void WriteValue(TextWriter writer, object value)

src/ServiceStack.Text/JsConfig.cs

@@ -778,6 +778,16 @@ public static Func<T, T> OnSerializingFn
             set { onSerializingFn = value; }
         }
 
+        /// <summary>
+        /// Define custom after serialization hook
+        /// </summary>
+        private static Action<T> onSerializedFn;
+        public static Action<T> OnSerializedFn
+        {
+            get { return onSerializedFn; }
+            set { onSerializedFn = value; }
+        }
+
         /// <summary>
         /// Define custom deserialization fn for BCL Structs
         /// </summary>

tests/ServiceStack.Text.Tests/SerializationHookTests.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Linq;
+using System.Runtime.Serialization;
+using NUnit.Framework;
+
+namespace ServiceStack.Text.Tests
+{
+    [TestFixture]
+    public class SerializationHookTests
+        : TestBase
+    {
+        [TestFixtureSetUp]
+        public void SetUp()
+        {
+            AddSerializeHooksForType<HookTestClass>();
+            AddSerializeHooksForType<HookTestSubClass>();
+        }
+
+        [Test]
+        public void TypeSerializer_Serialize_hooks_on_base_class()
+        {
+            var original = new HookTestClass();
+            var json = TypeSerializer.SerializeToString<HookTestClass>(original);
+
+            Assert.That(original.OnSerializedTouched, Is.True);
+            Assert.That(original.OnSerializingTouched, Is.True);
+        }
+
+        [Test]
+        public void TypeSerializer_Serialize_hooks_on_sub_class()
+        {
+            var original = new HookTestSubClass();
+            var json = TypeSerializer.SerializeToString<HookTestSubClass>(original);
+
+            Assert.That(original.OnSerializedTouched, Is.True);
+            Assert.That(original.OnSerializingTouched, Is.True);
+        }
+
+        [Test]
+        public void TypeSerializer_Deserialize_hooks_on_base_class()
+        {
+            var original = new HookTestClass();
+
+            var json = TypeSerializer.SerializeToString<HookTestClass>(original);
+            var deserialized = TypeSerializer.DeserializeFromString<HookTestClass>(json);
+
+            Assert.That(deserialized.OnDeserializedTouched, Is.True);
+        }
+
+        [Test]
+        public void TypeSerializer_Deserialize_hooks_on_sub_class()
+        {
+            var original = new HookTestSubClass();
+
+            var json = TypeSerializer.SerializeToString<HookTestSubClass>(original);
+            var deserialized = TypeSerializer.DeserializeFromString<HookTestSubClass>(json);
+
+            Assert.That(deserialized.OnDeserializedTouched, Is.True);
+        }
+
+        [Test]
+        public void JsonSerializer_Serialize_hooks_on_base_class()
+        {
+            var original = new HookTestClass();
+            var json = JsonSerializer.SerializeToString<HookTestClass>(original);
+
+            Assert.That(original.OnSerializedTouched, Is.True);
+            Assert.That(original.OnSerializingTouched, Is.True);
+        }
+
+        [Test]
+        public void JsonSerializer_Serialize_hooks_on_sub_class()
+        {
+            var original = new HookTestSubClass();
+            var json = JsonSerializer.SerializeToString<HookTestSubClass>(original);
+
+            Assert.That(original.OnSerializedTouched, Is.True);
+            Assert.That(original.OnSerializingTouched, Is.True);
+        }
+
+        [Test]
+        public void JsonSerializer_Deserialize_hooks_on_base_class()
+        {
+            var original = new HookTestClass();
+
+            var json = JsonSerializer.SerializeToString<HookTestClass>(original);
+            var deserialized = JsonSerializer.DeserializeFromString<HookTestClass>(json);
+
+            Assert.That(deserialized.OnDeserializedTouched, Is.True);
+        }
+
+        [Test]
+        public void JsonSerializer_Deserialize_hooks_on_sub_class()
+        {
+            var original = new HookTestSubClass();
+
+            var json = JsonSerializer.SerializeToString<HookTestSubClass>(original);
+            var deserialized = JsonSerializer.DeserializeFromString<HookTestSubClass>(json);
+
+            Assert.That(deserialized.OnDeserializedTouched, Is.True);
+        }
+
+        private void AddSerializeHooksForType<T>()
+        {
+            Type type = typeof(T);
+            System.Reflection.MethodInfo[] typeMethods = type.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+            var onSerializingMethods = typeMethods.Where(m => m.GetCustomAttributes(typeof(OnSerializingAttribute), true).Length > 0);
+            var OnDeserializedMethods = typeMethods.Where(m => m.GetCustomAttributes(typeof(OnDeserializedAttribute), true).Length > 0);
+            var OnSerializedMethods = typeMethods.Where(m => m.GetCustomAttributes(typeof(OnSerializedAttribute), true).Length > 0);
+            Object[] Parameters = { null };
+
+            if (onSerializingMethods.Any())
+            {
+                ServiceStack.Text.JsConfig<T>.OnSerializingFn = s =>
+                {
+                    foreach (var method in onSerializingMethods)
+                        method.Invoke(s, Parameters);
+
+                    return s;
+                };
+            }
+
+            if (OnSerializedMethods.Any())
+            {
+                ServiceStack.Text.JsConfig<T>.OnSerializedFn = s =>
+                {
+                    foreach (var method in OnSerializedMethods)
+                        method.Invoke(s, Parameters);
+                };
+            }
+
+            if (OnDeserializedMethods.Any())
+            {
+                ServiceStack.Text.JsConfig<T>.OnDeserializedFn = s =>
+                {
+                    foreach (var method in OnDeserializedMethods)
+                        method.Invoke(s, Parameters);
+
+                    return s;
+                };
+            }
+        }
+
+        class HookTestClass
+        {
+            public bool OnDeserializingTouched { get; set; }
+            public bool OnDeserializedTouched { get; set; }
+            public bool OnSerializingTouched { get; set; }
+            public bool OnSerializedTouched { get; set; }
+
+            /// <summary>
+            /// Will be executed when deserializing starts
+            /// </summary>
+            /// <param name="ctx"></param>
+            [OnDeserializing]
+            protected void OnDeserializing(StreamingContext ctx)
+            {
+                OnDeserializingTouched = true;
+            }
+
+            /// <summary>
+            /// Will be executed when deserializing finished
+            /// </summary>
+            /// <param name="ctx"></param>
+            [OnDeserialized]
+            protected void OnDeserialized(StreamingContext ctx)
+            {
+                OnDeserializedTouched = true;
+            }
+
+            /// <summary>
+            /// Will be executed when serializing starts
+            /// </summary>
+            /// <param name="ctx"></param>
+            [OnSerializing]
+            protected void OnSerializing(StreamingContext ctx)
+            {
+                OnSerializingTouched = true;
+            }
+
+            /// <summary>
+            /// Will be executed when serializing finished
+            /// </summary>
+            /// <param name="ctx"></param>
+            [OnSerialized]
+            protected void OnSerialized(StreamingContext ctx)
+            {
+                OnSerializedTouched = true;
+            }
+        }
+
+        class HookTestSubClass : HookTestClass
+        {
+        }
+    }
+}

tests/ServiceStack.Text.Tests/ServiceStack.Text.Tests.csproj

@@ -176,6 +176,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="SerializationHookTests.cs" />
     <Compile Include="StaticAccessorTests.cs" />
     <Compile Include="AdhocModelTests.cs" />
     <Compile Include="AnonymousTypes.cs" />