add base mapper

Paramore.Brighter.Perf/Benchmark.cs

@@ -0,0 +1,59 @@
+using System;
+using BenchmarkDotNet.Attributes;
+
+namespace Paramore.Brighter.Perf
+{
+    public class Benchmark
+    {
+        private readonly JsonMessageMapper<TestCommand> _jsonMessageMapper;
+        private readonly JsonMessageMapper2<TestCommand> _mapper2;
+        private readonly Message _message;
+        private readonly TestCommand _testCommand;
+
+        public Benchmark()
+        {
+            RequestContext requestContext = new RequestContext();
+            _jsonMessageMapper = new JsonMessageMapper<TestCommand>(requestContext);
+            _mapper2 = new JsonMessageMapper2<TestCommand>(requestContext);
+
+            DateTime dateTime = DateTime.UtcNow;
+            _testCommand = new TestCommand
+            {
+                Message = "This is a message",
+                Number = 999,
+                DateNow = dateTime
+            };
+
+            string body =
+                "{\"message\":\"This is a message\",\"number\":999,\"dateNow\":\"2019-04-09T15:06:56.7623017Z\",\"id\":\"7d9120b9-a18e-43ac-a63e-8201a43ea623\"}";
+            Guid correlationId = Guid.NewGuid();
+            _message = new Message(
+                new MessageHeader(new Guid("7d9120b9-a18e-43ac-a63e-8201a43ea623"), "Blah", MessageType.MT_COMMAND,
+                    correlationId), new MessageBody(body));
+        }
+
+        [Benchmark]
+        public void MapToMessageJsonByte()
+        {
+            _jsonMessageMapper.MapToMessage(_testCommand);
+        }
+
+        [Benchmark]
+        public void MapFromMessageJsonByte()
+        {
+            _jsonMessageMapper.MapToRequest(_message);
+        }
+
+        [Benchmark]
+        public void MapToMessageJsonString()
+        {
+            _mapper2.MapToMessage(_testCommand);
+        }
+
+        [Benchmark]
+        public void MapFromMessageJsonString()
+        {
+            _mapper2.MapToRequest(_message);
+        }
+    }
+}

Paramore.Brighter.Perf/Paramore.Brighter.Perf.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.11.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\Paramore.Brighter\Paramore.Brighter.csproj" />
+  </ItemGroup>
+
+</Project>

Paramore.Brighter.Perf/Program.cs

@@ -0,0 +1,26 @@
+using System;
+using BenchmarkDotNet.Running;
+
+namespace Paramore.Brighter.Perf
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var summary = BenchmarkRunner.Run<Benchmark>();
+            Console.WriteLine(summary);
+        }
+    }
+
+
+    public class TestCommand : Command
+    {
+        public TestCommand() : base(Guid.NewGuid())
+        {
+        }
+
+        public string Message { get; set; }
+        public int Number { get; set; }
+        public DateTime DateNow { get; set; }
+    }
+}

src/Paramore.Brighter/BaseMessageMapper.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Paramore.Brighter
+{
+    public abstract class BaseMessageMapper<T> : IAmAMessageMapper<T> where T : class, IRequest
+    {
+        private readonly IRequestContext _requestContext;
+        private readonly Func<T, string> _routingAction;
+        private readonly RoutingKey _routingKey;
+
+        protected BaseMessageMapper(IRequestContext requestContext, RoutingKey routingKey = null,  Func<T, string> routingKeyFunc = null)
+        {
+            _requestContext = requestContext;
+            _routingKey = routingKey;
+            _routingAction = routingKeyFunc;
+        }
+
+        public Message MapToMessage(T request)
+        {
+            MessageType messageType;
+            if (request is Command)
+                messageType = MessageType.MT_COMMAND;
+            else if (request is Event)
+                messageType = MessageType.MT_EVENT;
+            else
+            {
+                throw new ArgumentException("This message mapper can only map Commands and Events", nameof(request));
+            }
+
+            var topic = _routingAction?.Invoke(request) ?? _routingKey ?? request.GetType().Name;
+
+            var messageHeader = new MessageHeader(request.Id, topic, messageType, _requestContext.Header.CorrelationId, contentType: "application/json");
+
+            return new Message(messageHeader, CreateMessageBody(request));
+        }
+
+        protected abstract MessageBody CreateMessageBody(T request);
+
+        public T MapToRequest(Message message)
+        {
+            _requestContext.Header.CorrelationId = message.Header.CorrelationId;
+
+            return CreateType(message);
+        }
+
+        protected abstract T CreateType(Message message);
+    }
+}

src/Paramore.Brighter/JsonMessageMapper.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace Paramore.Brighter
+{
+    public class JsonMessageMapper<T> : BaseMessageMapper<T> where T : class, IRequest
+    {
+        private readonly JsonSerializer _serializer = new JsonSerializer();
+
+        public JsonMessageMapper(IRequestContext requestContext, RoutingKey routingKey = null,
+            Func<T, string> routingKeyFunc = null) : base(requestContext, routingKey, routingKeyFunc)
+        {
+        }
+
+        protected override MessageBody CreateMessageBody(T request)
+        {
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                using (StreamWriter streamWriter = new StreamWriter(memoryStream, new UTF8Encoding(false)))
+                using (JsonTextWriter jsonTextWriter = new JsonTextWriter(streamWriter))
+                {
+                    _serializer.Serialize(jsonTextWriter, request, typeof(T));
+                }
+
+                return new MessageBody(memoryStream.ToArray(), "JSON");
+            }
+        }
+
+        protected override T CreateType(Message message)
+        {
+            using (MemoryStream memoryStream = new MemoryStream(message.Body.Bytes))
+            using (StreamReader streamReader = new StreamReader(memoryStream, Encoding.UTF8))
+            using (JsonReader reader = new JsonTextReader(streamReader))
+            {
+                return _serializer.Deserialize<T>(reader);
+            }
+        }
+    }
+
+    public class JsonMessageMapper2<T> : BaseMessageMapper<T> where T : class, IRequest
+    {
+        public JsonMessageMapper2(IRequestContext requestContext, RoutingKey routingKey = null,
+            Func<T, string> routingKeyFunc = null) : base(requestContext, routingKey, routingKeyFunc)
+        {
+        }
+
+        protected override MessageBody CreateMessageBody(T request)
+        {
+                return new MessageBody(JsonConvert.SerializeObject(request), "JSON");
+        }
+
+        protected override T CreateType(Message message)
+        {
+            return JsonConvert.DeserializeObject<T>(message.Body.Value);
+        }
+    }
+}

tests/Paramore.Brighter.Core.Tests/MessageMapper/JsonMessageMapperTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Text;
 using Xunit;
 
 namespace Paramore.Brighter.Tests.MessageMapper
@@ -11,7 +10,7 @@ public void When_mapping_an_event_to_a_message_as_json()
         {
             var requestContext = new RequestContext();
 
-            var mapper = new GenericJsonMessageMapper<TestedEvent>(requestContext);
+            var mapper = new JsonMessageMapper<TestedEvent>(requestContext);
 
             DateTime dateTime = DateTime.UtcNow;
             TestedEvent testedEvent = new TestedEvent
@@ -45,7 +44,7 @@ public void When_mapping_a_command_to_a_message_as_json()
         {
             var requestContext = new RequestContext();
 
-            var mapper = new GenericJsonMessageMapper<TestCommand>(requestContext);
+            var mapper = new JsonMessageMapper<TestCommand>(requestContext);
 
             DateTime dateTime = DateTime.UtcNow;
             TestCommand testCommand = new TestCommand
@@ -73,10 +72,32 @@ public void When_mapping_a_command_to_a_message_as_json()
             Assert.Equal($"{{\"Message\":\"{testCommand.Message}\",\"Number\":{testCommand.Number},\"DateNow\":\"{dateTime:O}\",\"Id\":\"{testCommand.Id}\"}}", message.Body.Value);
         }
 
+        [Fact]
+        public void when_mapping_to_a_command_from_json()
+        {
+            var requestContext = new RequestContext();
+            var mapper = new JsonMessageMapper<TestCommand>(requestContext);
+
+
+            var body = "{\"message\":\"This is a message\",\"number\":999,\"dateNow\":\"2019-04-09T15:06:56.7623017Z\",\"id\":\"7d9120b9-a18e-43ac-a63e-8201a43ea623\"}";
+            var correlationId = Guid.NewGuid();
+            var message = new Message(new MessageHeader(new Guid("7d9120b9-a18e-43ac-a63e-8201a43ea623"),"Blah",  MessageType.MT_COMMAND, correlationId: correlationId), new MessageBody(body));
+
+            var testCommand = mapper.MapToRequest(message);
+
+
+            Assert.Equal("7d9120b9-a18e-43ac-a63e-8201a43ea623", testCommand.Id.ToString());
+            Assert.Equal("This is a message", testCommand.Message);
+            Assert.Equal(999, testCommand.Number);
+            Assert.Equal(DateTime.Parse("2019-04-09T15:06:56.7623017Z").ToUniversalTime(), testCommand.DateNow);
+
+            Assert.Equal(correlationId,  requestContext.Header.CorrelationId);
+        }
+
         [Fact]
         public void When_mapping_with_custom_routing_key_to_a_message()
         {
-            var mapper = new GenericJsonMessageMapper<TestCommand>(new RequestContext(), new RoutingKey("MyTestRoute"));
+            var mapper = new JsonMessageMapper<TestCommand>(new RequestContext(), new RoutingKey("MyTestRoute"));
 
             var testCommand = new TestCommand();
 
@@ -88,7 +109,7 @@ public void When_mapping_with_custom_routing_key_to_a_message()
         [Fact]
         public void When_mapping_with_custom_routing_key_to_a_message2()
         {
-            var mapper = new GenericJsonMessageMapper<TestCommand>(new RequestContext(), routingKeyFunc: request =>
+            var mapper = new JsonMessageMapper<TestCommand>(new RequestContext(), routingKeyFunc: request =>
             {
                 string topic = "TestPreAmble.";