Merge pull request #4 from Shuttle/async

Async

Author: eben-roux

README.md

@@ -14,6 +14,7 @@ The `DefaultSerializer` makes use of the standard .NET xml serialization functio
 
 ``` c#
 Stream Serialize(object message);
+Task<Stream> SerializeAsync(object message);
 ```
 
 Returns the message `object` as a `Stream`.
@@ -22,9 +23,10 @@ Returns the message `object` as a `Stream`.
 
 ``` c#
 object Deserialize(Type type, Stream stream);
+Task<object> DeserializeAsync(Type type, Stream stream);
 ```
 
-Deserializes the `Stream` into an `obejct` of the given type.
+Deserializes the `Stream` into an `object` of the given type.
 
 # ISerializerRootType
 

Shuttle.Core.Serialization.Tests/DefaultSerializerFixture.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 using NUnit.Framework;
 
 namespace Shuttle.Core.Serialization.Tests
@@ -23,6 +24,23 @@ public void Should_be_able_to_serialize_and_deserialize_a_simple_type()
             Assert.AreEqual(original.Id, ((SimpleSerializerType)serializer.Deserialize(typeof(SimpleSerializerType), stream)).Id);
         }
 
+        [Test]
+        public async Task Should_be_able_to_serialize_and_deserialize_a_simple_type_async()
+        {
+            var original = new SimpleSerializerType();
+            var serializer = new DefaultSerializer();
+
+            var stream = await serializer.SerializeAsync(original);
+
+            var xml = await new StreamReader(stream).ReadToEndAsync();
+
+            Assert.IsTrue(xml.Contains(original.Id.ToString()));
+
+            stream.Position = 0;
+
+            Assert.AreEqual(original.Id, ((SimpleSerializerType)await serializer.DeserializeAsync(typeof(SimpleSerializerType), stream)).Id);
+        }
+
         [Test]
         public void Should_be_able_to_serialize_and_deserialize_a_complex_type()
         {
@@ -51,5 +69,34 @@ public void Should_be_able_to_serialize_and_deserialize_a_complex_type()
             Assert.AreEqual(some1.Id, ((v1.SomeSerializerType)serializer.Deserialize(typeof(v1.SomeSerializerType), serializer.Serialize(some1))).Id);
             Assert.AreEqual(some2.Id, ((v2.SomeSerializerType)serializer.Deserialize(typeof(v2.SomeSerializerType), serializer.Serialize(some2))).Id);
         }
+
+        [Test]
+        public async Task Should_be_able_to_serialize_and_deserialize_a_complex_type_async()
+        {
+            var complex = new ComplexSerializerType();
+            var serializer = new DefaultSerializer();
+
+            serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.SomeSerializerType));
+            serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.AnotherSerializerType));
+            serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.SomeSerializerType));
+            serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.AnotherSerializerType));
+
+            var stream = await serializer.SerializeAsync(complex);
+            var xml = await new StreamReader(stream).ReadToEndAsync();
+
+            Assert.IsTrue(xml.Contains(complex.Id.ToString()));
+
+            stream.Position = 0;
+
+            Assert.AreEqual(complex.Id, ((ComplexSerializerType)await serializer.DeserializeAsync(typeof(ComplexSerializerType), stream)).Id);
+
+            Console.WriteLine(xml);
+
+            var some1 = new v1.SomeSerializerType();
+            var some2 = new v2.SomeSerializerType();
+
+            Assert.AreEqual(some1.Id, ((v1.SomeSerializerType)await serializer.DeserializeAsync(typeof(v1.SomeSerializerType), await serializer.SerializeAsync(some1))).Id);
+            Assert.AreEqual(some2.Id, ((v2.SomeSerializerType)await serializer.DeserializeAsync(typeof(v2.SomeSerializerType), await serializer.SerializeAsync(some2))).Id);
+        }
     }
 }

Shuttle.Core.Serialization.Tests/Shuttle.Core.Serialization.Tests.csproj

@@ -5,9 +5,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
-    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>
 
   <ItemGroup>

Shuttle.Core.Serialization/.package/package.nuspec

@@ -13,10 +13,10 @@
 		<repository type="git" url="https://github.com/shuttle/Shuttle.Core.Serialization.git" />
 		<projectUrl>https://github.com/shuttle/Shuttle.Core.Serialization</projectUrl>
 		<description>Serialization adapter.</description>
-		<copyright>Copyright (c) 2022, Eben Roux</copyright>
+		<copyright>Copyright (c) 2024, Eben Roux</copyright>
 		<tags>shuttle serialization</tags>
 		<dependencies>
-      <dependency id="Shuttle.Core.Contract" version="11.0.0" />
+      <dependency id="Shuttle.Core.Contract" version="11.1.0" />
 		</dependencies>
 	</metadata>
 	<files>

Shuttle.Core.Serialization/DefaultSerializer.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Reflection;
 using System.Text;
+using System.Threading.Tasks;
 using System.Xml;
 using System.Xml.Serialization;
 using Shuttle.Core.Contract;
@@ -26,6 +27,7 @@ public DefaultSerializer()
         {
             _xmlWriterSettings = new XmlWriterSettings
             {
+                Async = true,
                 Encoding = Encoding.UTF8,
                 OmitXmlDeclaration = true,
                 Indent = true
@@ -42,9 +44,18 @@ public DefaultSerializer()
         }
 
         public string Name => "Xml";
-        public byte Id => 1;
 
         public Stream Serialize(object instance)
+        {
+            return SerializeAsync(instance, true).GetAwaiter().GetResult();
+        }
+
+        public async Task<Stream> SerializeAsync(object instance)
+        {
+            return await SerializeAsync(instance, false).ConfigureAwait(false);
+        }
+
+        private async Task<Stream> SerializeAsync(object instance, bool sync)
         {
             Guard.AgainstNull(instance, nameof(instance));
 
@@ -53,38 +64,59 @@ public Stream Serialize(object instance)
 
             var xml = new StringBuilder();
 
-            using (var writer = XmlWriter.Create(xml, _xmlWriterSettings))
-            {
-                serializer.Serialize(writer, instance, _namespaces);
+            using var writer = XmlWriter.Create(xml, _xmlWriterSettings);
+            
+            serializer.Serialize(writer, instance, _namespaces);
 
+            if (sync)
+            {
                 writer.Flush();
             }
+            else
+            {
+                await writer.FlushAsync().ConfigureAwait(false);
+            }
 
             var data = Encoding.UTF8.GetBytes(xml.ToString());
+            
             return new MemoryStream(data, 0, data.Length, false, true);
         }
 
         public object Deserialize(Type type, Stream stream)
+        {
+            return DeserializeAsync(type, stream, true).GetAwaiter().GetResult();
+        }
+
+        public async Task<object> DeserializeAsync(Type type, Stream stream)
+        {
+            return await DeserializeAsync(type, stream, false).ConfigureAwait(false);
+        }
+
+        private async Task<object> DeserializeAsync(Type type, Stream stream, bool sync)
         {
             Guard.AgainstNull(type, nameof(type));
             Guard.AgainstNull(stream, nameof(stream));
 
-            using (var copy = new MemoryStream())
-            {
-                var position = stream.Position;
+            using var copy = new MemoryStream();
+            var position = stream.Position;
 
-                stream.Position = 0;
+            stream.Position = 0;
+
+            if (sync)
+            {
                 stream.CopyTo(copy);
+            }
+            else
+            {
+                await stream.CopyToAsync(copy).ConfigureAwait(false);
+            }
 
-                stream.Position = position;
-                copy.Position = 0;
+            stream.Position = position;
+            copy.Position = 0;
 
-                
-                using (var reader = XmlDictionaryReader.CreateTextReader(copy, Encoding.UTF8, _xmlDictionaryReaderQuotas, null))
-                {
-                    return GetSerializer(type).Deserialize(reader);
-                }
-            }
+            using var reader = XmlDictionaryReader.CreateTextReader(copy, Encoding.UTF8, _xmlDictionaryReaderQuotas, null);
+
+            return GetSerializer(type).Deserialize(reader);
         }
 
         public void AddSerializerType(Type root, Type contained)

Shuttle.Core.Serialization/ISerializer.cs

@@ -1,13 +1,15 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 
 namespace Shuttle.Core.Serialization
 {
     public interface ISerializer
     {
         string Name { get; }
-        byte Id { get; }
         Stream Serialize(object instance);
         object Deserialize(Type type, Stream stream);
+        Task<Stream> SerializeAsync(object instance);
+        Task<object> DeserializeAsync(Type type, Stream stream);
     }
 }

Shuttle.Core.Serialization/ISerializerService.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace Shuttle.Core.Serialization
+{
+    public interface ISerializerService
+    {
+        ISerializerService Add(ISerializer serializer);
+        ISerializer Get(string name);
+        bool Contains(string name);
+        IEnumerable<ISerializer> Serializers { get; }
+    }
+}

Shuttle.Core.Serialization/Properties/AssemblyInfo.cs

@@ -14,7 +14,7 @@
 #endif
 
 [assembly: AssemblyVersion("11.0.0.0")]
-[assembly: AssemblyCopyright("Copyright (c) 2022, Eben Roux")]
+[assembly: AssemblyCopyright("Copyright (c) 2024, Eben Roux")]
 [assembly: AssemblyProduct("Shuttle.Core.Serialization")]
 [assembly: AssemblyCompany("Eben Roux")]
 [assembly: AssemblyConfiguration("Release")]