Adding support for custom serialization (#73)

Author: Anouar Hassine

ReactiveXComponent/Common/MessageEventArgs.cs

@@ -1,5 +1,4 @@
-using Newtonsoft.Json.Linq;
-using ReactiveXComponent.Serializer;
+using ReactiveXComponent.Serializer;
 
 namespace ReactiveXComponent.Common
 {
@@ -22,19 +21,8 @@ public MessageEventArgs(StateMachineRefHeader stateMachineRefHeader, object mess
 
         public T GetMessage<T>() where T : class
         {
-            if (SerializationType == SerializationType.Binary)
-            {
-                return MessageReceived as T;
-            }
-
-            if (SerializationType == SerializationType.Json
-                     || SerializationType == SerializationType.Bson)
-            {
-                var jResult = MessageReceived as JObject;
-                return jResult?.ToObject<T>();
-            }
-
-            return null;
+            var serializer = SerializerFactory.CreateSerializer(SerializationType);
+            return serializer.CastObject<T>(MessageReceived);
         }
     }
 }

ReactiveXComponent/ReactiveXComponent.csproj

@@ -116,6 +116,8 @@
     <Compile Include="Common\ReactiveXComponentException.cs" />
     <Compile Include="Serializer\BinarySerializer.cs" />
     <Compile Include="Serializer\BsonSerializer.cs" />
+    <Compile Include="Serializer\CustomSerializerAttribute.cs" />
+    <Compile Include="Serializer\CustomSerializerContainerAttribute.cs" />
     <Compile Include="Serializer\ISerializer.cs" />
     <Compile Include="Serializer\JsonSerializer.cs" />
     <Compile Include="Serializer\SerializationType.cs" />

ReactiveXComponent/Serializer/BinarySerializer.cs

@@ -38,5 +38,10 @@ public object Deserialize(Stream stream)
 
             return obj;
         }
+
+        public T CastObject<T>(object message) where T : class
+        {
+            return message as T;
+        }
     }
 }

ReactiveXComponent/Serializer/BsonSerializer.cs

@@ -1,5 +1,6 @@
 using System.IO;
 using Newtonsoft.Json.Bson;
+using Newtonsoft.Json.Linq;
 
 namespace ReactiveXComponent.Serializer
 {
@@ -20,5 +21,10 @@ public object Deserialize(Stream stream)
             return _serializer.Deserialize(bsonReader);
         }
 
+        public T CastObject<T>(object message) where T : class
+        {
+            var jResult = message as JObject;
+            return jResult?.ToObject<T>();
+        }
     }
 }

ReactiveXComponent/Serializer/CustomSerializerAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace ReactiveXComponent.Serializer
+{
+    [AttributeUsage(AttributeTargets.Class, Inherited = false)]
+    public class CustomSerializerAttribute : Attribute
+    {
+    }
+}

ReactiveXComponent/Serializer/CustomSerializerContainerAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace ReactiveXComponent.Serializer
+{
+    [AttributeUsage(AttributeTargets.Assembly)]
+    public class CustomSerializerContainerAttribute : Attribute
+    {
+    }
+}

ReactiveXComponent/Serializer/ISerializer.cs

@@ -5,6 +5,7 @@ namespace ReactiveXComponent.Serializer
     public interface ISerializer
     {
         object Deserialize(Stream stream);
+        T CastObject<T>(object message) where T : class;
         void Serialize(Stream stream, object message);
     }
 }

ReactiveXComponent/Serializer/JsonSerializer.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace ReactiveXComponent.Serializer
 {
@@ -40,5 +41,11 @@ public object Deserialize(Stream stream)
                 throw new XCSerializationException(e.Message, e);
             }
         }
+
+        public T CastObject<T>(object message) where T : class
+        {
+            var jResult = message as JObject;
+            return jResult?.ToObject<T>();
+        }
     }
 }

ReactiveXComponent/Serializer/SerializationType.cs

@@ -4,6 +4,7 @@ public enum SerializationType
     {
         Binary = 0,
         Json = 1,
-        Bson = 2
+        Bson = 2,
+        Custom = 3
     }
 }

ReactiveXComponent/Serializer/SerializerFactory.cs

@@ -1,7 +1,14 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
 namespace ReactiveXComponent.Serializer
 {
     public static class SerializerFactory
     {
+        private static ISerializer _customSerializer;
+        private static readonly object CustomSerializerLock = new object();
+
         public static ISerializer CreateSerializer(SerializationType serializationType)
         {
             switch (serializationType)
@@ -12,9 +19,53 @@ public static ISerializer CreateSerializer(SerializationType serializationType)
                     return new JsonSerializer();
                 case SerializationType.Bson:
                     return new BsonSerializer();
+                case SerializationType.Custom:
+                    return FindCustomSerializer();
                 default:
                     throw new XCSerializationException("Unhandled serialization type " + serializationType);
             }
         }
+
+        private static ISerializer FindCustomSerializer()
+        {
+            if (_customSerializer == null)
+            {
+                lock (CustomSerializerLock)
+                {
+                    if (_customSerializer == null)
+                    {
+                        ISerializer customSerializer = null;
+
+                        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+                        {
+                            if (assembly.GetCustomAttributes().OfType<CustomSerializerContainerAttribute>().Any())
+                            {
+                                foreach (var exportedType in assembly.GetExportedTypes())
+                                {
+                                    var customSerializerAttribute = exportedType.GetCustomAttributes()
+                                        .OfType<CustomSerializerAttribute>()
+                                        .FirstOrDefault();
+
+                                    if (customSerializerAttribute != null)
+                                    {
+                                        customSerializer = (ISerializer)Activator.CreateInstance(exportedType);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (customSerializer == null)
+                        {
+                            throw new XCSerializationException("Unable to find a custom serializer");
+                        }
+
+                        _customSerializer = customSerializer;
+                    }
+                }
+            }
+
+            return _customSerializer;
+        }
     }
 }