Abstract serialization/deserialization of storage objects. Fix #163 (#166)

* Abstract serialization/deserialization of storage objects (events and settings).

Author: edwardmeng

src/Exceptionless/Dependency/DependencyResolver.cs

@@ -33,6 +33,9 @@ public static void RegisterDefaultServices(IDependencyResolver resolver) {
             var jsonSerializer = new Lazy<IJsonSerializer>(() => resolver.Resolve<DefaultJsonSerializer>());
             resolver.Register(typeof(IJsonSerializer), () => jsonSerializer.Value);
 
+            var storageSerializer = new Lazy<IStorageSerializer>(() => resolver.Resolve<DefaultJsonSerializer>());
+            resolver.Register(typeof(IStorageSerializer), () => storageSerializer.Value);
+
             var eventQueue = new Lazy<IEventQueue>(() => resolver.Resolve<DefaultEventQueue>());
             resolver.Register(typeof(IEventQueue), () => eventQueue.Value);
 

src/Exceptionless/Dependency/DependencyResolverExtensions.cs

@@ -70,6 +70,10 @@ public static IJsonSerializer GetJsonSerializer(this IDependencyResolver resolve
             return resolver.Resolve<IJsonSerializer>() ?? resolver.Resolve<DefaultJsonSerializer>();
         }
 
+        public static IStorageSerializer GetStorageSerializer(this IDependencyResolver resolver) {
+            return resolver.Resolve<IStorageSerializer>() ?? resolver.Resolve<DefaultJsonSerializer>();
+        }
+
         public static IEventQueue GetEventQueue(this IDependencyResolver resolver) {
             return resolver.Resolve<IEventQueue>() ?? resolver.Resolve<DefaultEventQueue>();
         }

src/Exceptionless/Serializer/DefaultJsonSerializer.cs

@@ -10,7 +10,7 @@
 using Exceptionless.Json.Serialization;
 
 namespace Exceptionless.Serializer {
-    public class DefaultJsonSerializer : IJsonSerializer {
+    public class DefaultJsonSerializer : IJsonSerializer, IStorageSerializer {
         private readonly JsonSerializerSettings _serializerSettings;
 
         public DefaultJsonSerializer() {
@@ -25,6 +25,22 @@ public DefaultJsonSerializer() {
             _serializerSettings.Converters.Add(new RequestInfoConverter());
         }
 
+        public virtual void Serialize<T>(T data, Stream outputStream) {
+            using (var writer = new StreamWriter(outputStream)) {
+                writer.Write(Serialize(data));
+            }
+        }
+
+        public virtual T Deserialize<T>(Stream inputStream) {
+            using (var reader = new StreamReader(inputStream)) {
+                var json = reader.ReadToEnd();
+                if (String.IsNullOrWhiteSpace(json))
+                    return default(T);
+
+                return JsonConvert.DeserializeObject<T>(json, _serializerSettings);
+            }
+        }
+
         public virtual string Serialize(object model, string[] exclusions = null, int maxDepth = 10, bool continueOnSerializationError = true) {
             if (model == null)
                 return null;

src/Exceptionless/Serializer/IStorageSerializer.cs

@@ -0,0 +1,8 @@
+using System.IO;
+
+namespace Exceptionless.Serializer {
+    public interface IStorageSerializer{
+        void Serialize<T>(T data, Stream output);
+        T Deserialize<T>(Stream input);
+    }
+}

src/Exceptionless/Storage/FolderObjectStorage.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using Exceptionless.Dependency;
 using Exceptionless.Extensions;
+using Exceptionless.Models;
 using Exceptionless.Utility;
 
 namespace Exceptionless.Storage {
@@ -34,13 +35,11 @@ public T GetObject<T>(string path) where T : class {
                 throw new ArgumentNullException("path");
 
             try {
-                var json = File.ReadAllText(Path.Combine(Folder, path));
-                if (String.IsNullOrEmpty(json))
-                    return null;
-
-                var serializer = _resolver.GetJsonSerializer();
-                return serializer.Deserialize<T>(json);
-            } catch (Exception ex) {
+                using (var reader = File.OpenRead(Path.Combine(Folder, path))) {
+                    return _resolver.GetStorageSerializer().Deserialize<T>(reader);
+                }
+            }
+            catch (Exception ex) {
                 _resolver.GetLog().Error(ex.Message, exception: ex);
                 return null;
             }
@@ -71,10 +70,11 @@ public bool SaveObject<T>(string path, T value) where T : class {
                 Directory.CreateDirectory(directory);
 
             try {
-                var serializer = _resolver.GetJsonSerializer();
-                string json = serializer.Serialize(value);
-                File.WriteAllText(Path.Combine(Folder, path), json);
-            } catch (Exception ex) {
+                using (var writer = File.OpenWrite(Path.Combine(Folder, path))) {
+                    _resolver.GetStorageSerializer().Serialize(value, writer);
+                }
+            }
+            catch (Exception ex) {
                 _resolver.GetLog().Error(ex.Message, exception: ex);
                 return false;
             }

src/Exceptionless/Storage/IsolatedStorageObjectStorage.cs

@@ -6,16 +6,19 @@
 using System.IO.IsolatedStorage;
 using System.Linq;
 using System.Reflection;
+using System.Text;
 using System.Text.RegularExpressions;
 using Exceptionless.Dependency;
 using Exceptionless.Extensions;
+using Exceptionless.Models;
 using Exceptionless.Storage;
 using Exceptionless.Utility;
 
 namespace Exceptionless.Storage {
     public class IsolatedStorageObjectStorage : IObjectStorage {
         private readonly object _lockObject = new object();
         private readonly IDependencyResolver _resolver;
+        private static readonly Encoding _encodingUTF8NoBOM = new UTF8Encoding(false, true);
 
         public IsolatedStorageObjectStorage(IDependencyResolver resolver) {
             _resolver = resolver;
@@ -97,21 +100,20 @@ public T GetObject<T>(string path) where T : class {
                 throw new ArgumentNullException("path");
 
             try {
-                var json = Run.WithRetries(() => {
+                var buffer = Run.WithRetries(() => {
                     using (var store = GetIsolatedStorage()) {
                         using (var stream = new IsolatedStorageFileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, store)) {
-                            using (var reader = new StreamReader(stream)) {
-                                return reader.ReadToEnd();
+                            using (var memory = new MemoryStream()) {
+                                stream.CopyTo(memory);
+                                return memory.ToArray();
                             }
                         }
                     }
                 });
 
-                if (String.IsNullOrEmpty(json))
-                    return null;
-
-                var serializer = _resolver.GetJsonSerializer();
-                return serializer.Deserialize<T>(json);
+                if (buffer == null || buffer.Length == 0)
+                    return default(T);
+                return _resolver.GetStorageSerializer().Deserialize<T>(new MemoryStream(buffer));
             } catch (Exception ex) {
                 _resolver.GetLog().Error(ex.Message, exception: ex);
                 return null;
@@ -123,11 +125,12 @@ public bool SaveObject<T>(string path, T value) where T : class {
                 throw new ArgumentNullException("path");
 
             EnsureDirectory(path);
-
-            string json;
+            byte[] buffer;
             try {
-                var serializer = _resolver.GetJsonSerializer();
-                json = serializer.Serialize(value);
+                using (var memory = new MemoryStream()) {
+                    _resolver.GetStorageSerializer().Serialize(value, memory);
+                    buffer = memory.ToArray();
+                }
             } catch (Exception ex) {
                 _resolver.GetLog().Error(ex.Message, exception: ex);
                 return false;
@@ -138,9 +141,7 @@ public bool SaveObject<T>(string path, T value) where T : class {
                     Run.WithRetries(() => {
                         using (var store = GetIsolatedStorage()) {
                             using (var stream = new IsolatedStorageFileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, store)) {
-                                using (var streamWriter = new StreamWriter(stream)) {
-                                    streamWriter.Write(json);
-                                }
+                                stream.Write(buffer,0,buffer.Length);
                             }
                         }
                     });

test/Exceptionless.Tests/Storage/FolderFileStorageTests.cs

@@ -12,6 +12,7 @@ public class FolderFileStorageTests : FileStorageTestsBase {
         protected override IObjectStorage GetStorage() {
             var resolver = new DefaultDependencyResolver();
             resolver.Register<IJsonSerializer, DefaultJsonSerializer>();
+            resolver.Register<IStorageSerializer, DefaultJsonSerializer>();
             return new FolderObjectStorage(resolver, "temp");
         }
 

test/Exceptionless.Tests/Storage/IsolatedStorageFileStorageTests.cs

@@ -8,6 +8,7 @@ public class IsolatedStorageFileStorageTests : FileStorageTestsBase {
         protected override IObjectStorage GetStorage() {
             var resolver = new DefaultDependencyResolver();
             resolver.Register<IJsonSerializer, DefaultJsonSerializer>();
+            resolver.Register<IStorageSerializer, DefaultJsonSerializer>();
             return new IsolatedStorageObjectStorage(resolver);
         }
     }