Your envelope is not my envelope - easy conversion from the untyped usage on the dispatcher side to the typed usage on the handler side.

Author: yreynhout

src/Recipes/Enveloping/Usage.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
 using System.Runtime.Caching;
 using System.Threading.Tasks;
 using NUnit.Framework;
@@ -21,43 +24,85 @@ public async Task Show()
                         Resolve.WhenEqualToHandlerMessageType(new Projection().Handlers)).
                     ProjectAsync(cache, new object[]
                     {
-                        new Envelope<PortfolioAdded>(
+                        new Envelope(
                             new PortfolioAdded {Id = portfolioId, Name = "My portfolio"},
                             new Dictionary<string, object>
                             {
                                 {"Position", 0L}
-                            }),
-                        new Envelope<PortfolioRenamed>(
+                            }).ToGenericEnvelope(),
+                        new Envelope(
                             new PortfolioRenamed {Id = portfolioId, Name = "Your portfolio"},
                             new Dictionary<string, object>
                             {
                                 {"Position", 1L}
-                            }),
-                        new Envelope<PortfolioRemoved>(
+                            }).ToGenericEnvelope(),
+                        new Envelope(
                             new PortfolioRemoved {Id = portfolioId},
                             new Dictionary<string, object>
                             {
                                 {"Position", 2L}
-                            })
+                            }).ToGenericEnvelope()
                     });
             }
         }
 
-        class Envelope<TMessage>
+        class Envelope<TMessage> //Used by handlers
         {
-            public Envelope(TMessage message, IDictionary<string, object> metadata)
+            private readonly Envelope _envelope;
+
+            public Envelope(Envelope envelope)
+            {
+                if (envelope == null)
+                    throw new ArgumentNullException(nameof(envelope));
+                _envelope = envelope;
+            }
+
+            public TMessage Message => (TMessage) _envelope.Message;
+            public long Position => (long)_envelope.Metadata["Position"];
+        }
+
+        class Envelope //Used by dispatchers
+        {
+            //Note we could precompute these factories for all known message types.
+            private static readonly ConcurrentDictionary<Type, Func<Envelope, object>> Factories = 
+                new ConcurrentDictionary<Type, Func<Envelope, object>>();
+
+            public Envelope(object message, IReadOnlyDictionary<string, object> metadata)
             {
+                if (message == null)
+                    throw new ArgumentNullException(nameof(message));
                 if (metadata == null)
                     throw new ArgumentNullException(nameof(metadata));
                 Message = message;
                 Metadata = metadata;
             }
 
-            public TMessage Message { get; }
-            public IDictionary<string, object> Metadata { get; }
-            public long Position => (long)Metadata["Position"];
+            public object Message { get; }
+            public IReadOnlyDictionary<string, object> Metadata { get; }
+
+            public object ToGenericEnvelope()
+            {
+                var factory = Factories
+                    .GetOrAdd(Message.GetType(), typeOfMessage =>
+                    {
+                        var parameter = Expression
+                            .Parameter(typeof(Envelope), "envelope");
+                        return Expression
+                            .Lambda<Func<Envelope, object>>(
+                                Expression.New(
+                                    typeof(Envelope<>)
+                                        .MakeGenericType(typeOfMessage)
+                                        .GetConstructors()
+                                        .Single(),
+                                    parameter),
+                                parameter)
+                            .Compile();
+                    });
+                return factory(this);
+            }
         }
 
+
         class Projection : ConnectedProjection<MemoryCache>
         {
             public Projection()
@@ -79,7 +124,7 @@ public Projection()
                 });
                 When<Envelope<PortfolioRemoved>>((cache, envelope) =>
                 {
-                    cache.Remove(envelope.Message.Id.ToString());
+                    'cache.Remove(envelope.Message.Id.ToString());
                 });
                 When<Envelope<PortfolioRenamed>>((cache, envelope) =>
                 {