Adding ITypeNameSerializer to control how message types are converted to / from strings

Author: ejsmith

src/Foundatio.TestHarness/Messaging/MessageBusTestBase.cs

@@ -108,7 +108,7 @@ await messageBus.PublishAsync(new DerivedSimpleMessageA {
 
         public virtual async Task CanSendMappedMessageAsync() {
             var messageBus = GetMessageBus(b => {
-                b.MessageTypeMappings.Add(nameof(SimpleMessageA), typeof(SimpleMessageA));
+                b.TypeNameSerializer = new DefaultTypeNameSerializer(_logger, new Dictionary<string, Type> {{ nameof(SimpleMessageA), typeof(SimpleMessageA) }});
                 return b;
             });
             if (messageBus == null)

src/Foundatio/Messaging/ITypeNameSerializer.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Foundatio.Messaging {
+    public interface ITypeNameSerializer {
+        string Serialize(Type type);
+        Type Deserialize(string typeName);
+    }
+
+    public class DefaultTypeNameSerializer : ITypeNameSerializer {
+        private readonly Dictionary<string, Type> _typeNameOverrides;
+        private readonly ILogger _logger;
+
+        public DefaultTypeNameSerializer(ILogger logger = null, IDictionary<string, Type> typeNameOverrides = null) {
+            _logger = logger ?? NullLogger.Instance;
+            _typeNameOverrides = typeNameOverrides != null ? new Dictionary<string, Type>(typeNameOverrides) : new Dictionary<string, Type>();
+        }
+
+        private readonly ConcurrentDictionary<string, Type> _knownMessageTypesCache = new ConcurrentDictionary<string, Type>();
+        public Type Deserialize(string typeName) {
+            return _knownMessageTypesCache.GetOrAdd(typeName, newTypeName => {
+                if (_typeNameOverrides != null && _typeNameOverrides.ContainsKey(newTypeName))
+                    return _typeNameOverrides[newTypeName];
+
+                try {
+                    return Type.GetType(newTypeName);
+                } catch (Exception ex) {
+                    if (_logger.IsEnabled(LogLevel.Warning))
+                        _logger.LogWarning(ex, "Error getting message type: {MessageType}", newTypeName);
+
+                    return null;
+                }
+            });
+        }
+
+        private readonly ConcurrentDictionary<Type, string> _mappedMessageTypesCache = new ConcurrentDictionary<Type, string>();
+        public string Serialize(Type type) {
+            return _mappedMessageTypesCache.GetOrAdd(type, newType => {
+                var reversedMap = _typeNameOverrides.ToDictionary(kvp => kvp.Value, kvp => kvp.Key);
+                if (reversedMap.ContainsKey(newType))
+                    return reversedMap[newType];
+                
+                return String.Concat(type.FullName, ", ", type.Assembly.GetName().Name);
+            });
+        }
+    }
+}

src/Foundatio/Messaging/MessageBusBase.cs

@@ -18,13 +18,15 @@ public abstract class MessageBusBase<TOptions> : IMessageBus, IDisposable where
         protected readonly TOptions _options;
         protected readonly ILogger _logger;
         protected readonly ISerializer _serializer;
+        protected readonly ITypeNameSerializer _typeNameSerializer;
         private bool _isDisposed;
 
         public MessageBusBase(TOptions options) {
             _options = options ?? throw new ArgumentNullException(nameof(options));
             var loggerFactory = options?.LoggerFactory ?? NullLoggerFactory.Instance;
             _logger = loggerFactory.CreateLogger(GetType());
             _serializer = options.Serializer ?? DefaultSerializer.Instance;
+            _typeNameSerializer = options.TypeNameSerializer ?? new DefaultTypeNameSerializer(_logger);
             MessageBusId = _options.Topic + Guid.NewGuid().ToString("N").Substring(10);
             _messageBusDisposedCancellationTokenSource = new CancellationTokenSource();
         }
@@ -39,32 +41,12 @@ public async Task PublishAsync(Type messageType, object message, TimeSpan? delay
             await PublishImplAsync(messageType, message, delay, cancellationToken).AnyContext();
         }
 
-        private readonly ConcurrentDictionary<Type, string> _mappedMessageTypesCache = new ConcurrentDictionary<Type, string>();
         protected string GetMappedMessageType(Type messageType) {
-            return _mappedMessageTypesCache.GetOrAdd(messageType, type => {
-                var reversedMap = _options.MessageTypeMappings.ToDictionary(kvp => kvp.Value, kvp => kvp.Key);
-                if (reversedMap.ContainsKey(type))
-                    return reversedMap[type];
-                
-                return String.Concat(messageType.FullName, ", ", messageType.Assembly.GetName().Name);
-            });
+            return _typeNameSerializer.Serialize(messageType);
         }
 
-        private readonly ConcurrentDictionary<string, Type> _knownMessageTypesCache = new ConcurrentDictionary<string, Type>();
         protected Type GetMappedMessageType(string messageType) {
-            return _knownMessageTypesCache.GetOrAdd(messageType, type => {
-                if (_options.MessageTypeMappings != null && _options.MessageTypeMappings.ContainsKey(type))
-                    return _options.MessageTypeMappings[type];
-
-                try {
-                    return Type.GetType(type);
-                } catch (Exception ex) {
-                    if (_logger.IsEnabled(LogLevel.Warning))
-                        _logger.LogWarning(ex, "Error getting message body type: {MessageType}", type);
-
-                    return null;
-                }
-            });
+            return _typeNameSerializer.Deserialize(messageType);
         }
 
         protected virtual Task EnsureTopicSubscriptionAsync<T>(CancellationToken cancellationToken) where T : class => Task.CompletedTask;

src/Foundatio/Messaging/SharedMessageBusOptions.cs

@@ -9,9 +9,9 @@ public class SharedMessageBusOptions : SharedOptions {
         public string Topic { get; set; } = "messages";
 
         /// <summary>
-        /// Controls which types messages are mapped to.
+        /// Controls how message types are serialized to/from strings.
         /// </summary>
-        public Dictionary<string, Type> MessageTypeMappings { get; set; } = new Dictionary<string, Type>();
+        public ITypeNameSerializer TypeNameSerializer { get; set; }
     }
 
     public class SharedMessageBusOptionsBuilder<TOptions, TBuilder> : SharedOptionsBuilder<TOptions, TBuilder>
@@ -23,20 +23,9 @@ public TBuilder Topic(string topic) {
             Target.Topic = topic;
             return (TBuilder)this;
         }
-
-        public TBuilder MapMessageType<T>(string name) {
-            if (Target.MessageTypeMappings == null)
-                Target.MessageTypeMappings = new Dictionary<string, Type>();
-            
-            Target.MessageTypeMappings[name] = typeof(T);
-            return (TBuilder)this;
-        }
-
-        public TBuilder MapMessageTypeToClassName<T>() {
-            if (Target.MessageTypeMappings == null)
-                Target.MessageTypeMappings = new Dictionary<string, Type>();
-            
-            Target.MessageTypeMappings[typeof(T).Name] = typeof(T);
+        
+        public TBuilder TypeNameSerializer(ITypeNameSerializer typeNameSerializer) {
+            Target.TypeNameSerializer = typeNameSerializer;
             return (TBuilder)this;
         }
     }