[Host] Ability to add assembly or type redirect names in AssemblyQualifiedNameMessageTypeResolver

Signed-off-by: Tomasz Maruszak <maruszaktomasz@gmail.com>

Author: zarusz

docs/intro.md

@@ -30,6 +30,9 @@
 - [Serialization](#serialization)
 - [Multiple message types on one topic (or queue)](#multiple-message-types-on-one-topic-or-queue)
   - [Message Type Resolver](#message-type-resolver)
+    - [Custom Message Type Resolvers](#custom-message-type-resolvers)
+    - [Use Case: Type Redirection for Evolving Services](#use-case-type-redirection-for-evolving-services)
+      - [Using Redirects with the Default Resolver](#using-redirects-with-the-default-resolver)
   - [Polymorphic messages](#polymorphic-messages)
     - [Polymorphic producer](#polymorphic-producer)
     - [Polymorphic consumer](#polymorphic-consumer)
@@ -844,17 +847,84 @@ mbb.Consume<OrderEvent>(x =>
 
 ### Message Type Resolver
 
-By default, the message header `MessageType` conveys the message type information using the assembly qualified name of the .NET type (see `AssemblyQualifiedNameMessageTypeResolver`).
+SlimMessageBus uses the `MessageType` header to convey the message's type information as a `string`. This allows the consumer to determine the correct .NET `Type` needed to deserialize the payload.
 
-A custom resolver could be used. Some scenarios include a desire to send short type names (to optimize overall message size) or adjust interoperability with other messaging systems.
-The following can be used to provide a custom `IMessageTypeResolver` implementation:
+- **Producer Side:** Converts the `.NET Type` to a string and adds it to the message header.
+- **Consumer Side:** Reads the string from the header, resolves the corresponding `Type`, and passes it to the serializer to deserialize the message before handing it off to the appropriate handler.
 
-```cs
-IMessageTypeResolver mtr = new AssemblyQualifiedNameMessageTypeResolver();
+Type resolution is handled via the [`IMessageTypeResolver`](/src/SlimMessageBus.Host/MessageTypeResolver/IMessageTypeResolver.cs) interface, which is resolved from the dependency injection (DI) container.
+
+By default, SlimMessageBus registers the [`AssemblyQualifiedNameMessageTypeResolver`](/src/SlimMessageBus.Host/MessageTypeResolver/AssemblyQualifiedNameMessageTypeResolver.cs), which formats the type name as an **assembly-qualified name (without the version number)**. For example:
+
+```
+MyNamespace.MyMessage, MyAssembly
+```
+
+#### Custom Message Type Resolvers
+
+You can provide a custom implementation of `IMessageTypeResolver` to support scenarios like:
+
+- Reducing message size by using short or alias-based type names.
+- Integrating with other messaging systems using different naming conventions.
+- Supporting versioning or refactoring, such as type or namespace changes.
+
+**Example – Custom Resolver Registration**
+
+```csharp
+public class MyShortNameMessageTypeResolver : IMessageTypeResolver
+{
+    // Implement custom logic to map between Type and string.
+    // Useful for short names, legacy mappings, etc.
+}
+
+// Register with Microsoft DI
+services.AddSingleton<MyShortNameMessageTypeResolver>();
+
+services.AddSlimMessageBus(mbb =>
+{
+    // If this were to be a hybrid bus, each child bus can have its own type resolver
+    mbb.WithMessageTypeResolver<MyShortNameMessageTypeResolver>();
+});
+```
 
-mbb.WithMessageTypeResolver(mtr)
+#### Use Case: Type Redirection for Evolving Services
+
+Suppose you refactor a service, moving messages to a new assembly or namespace. Since producers and consumers may be deployed independently, you’ll need a strategy to handle message type mismatches between versions.
+
+With a custom resolver, you can:
+
+- **Redirect** incoming messages that reference old type names to the updated `Type`.
+- **Emit** legacy type names from the producer for backward compatibility.
+
+##### Using Redirects with the Default Resolver
+
+If you're using the default [`AssemblyQualifiedNameMessageTypeResolver`](/src/SlimMessageBus.Host/MessageTypeResolver/AssemblyQualifiedNameMessageTypeResolver.cs), you can extend it by implementing [`IAssemblyQualifiedNameMessageTypeResolverRedirect`](/src/SlimMessageBus.Host/MessageTypeResolver/IAssemblyQualifiedNameMessageTypeResolverRedirect.cs).
+
+```csharp
+public class MyTypeResolverRedirect : IAssemblyQualifiedNameMessageTypeResolverRedirect
+{
+    public Type TryGetType(string name)
+    {
+        if (name == "MyNamespace.MyMessage, MyAssembly")
+        {
+            return Type.GetType("NewNamespace.MyMessage, NewAssembly");
+            // or return typeof(MyMessage);
+        }
+        return null; // no match
+    }
+
+    public string TryGetName(Type messageType) => null; // No outgoing redirect
+}
 ```
 
+These redirect services must be registered with DI. You can register multiple for modularity:
+
+```csharp
+services.TryAddEnumerable<IAssemblyQualifiedNameMessageTypeResolverRedirect, MyTypeResolverRedirect>();
+```
+
+This makes it easy to maintain compatibility as your services evolve, without disrupting production systems.
+
 ### Polymorphic messages
 
 SMB supports working with message hierarchies.

docs/intro.t.md

@@ -30,6 +30,9 @@
 - [Serialization](#serialization)
 - [Multiple message types on one topic (or queue)](#multiple-message-types-on-one-topic-or-queue)
   - [Message Type Resolver](#message-type-resolver)
+    - [Custom Message Type Resolvers](#custom-message-type-resolvers)
+    - [Use Case: Type Redirection for Evolving Services](#use-case-type-redirection-for-evolving-services)
+      - [Using Redirects with the Default Resolver](#using-redirects-with-the-default-resolver)
   - [Polymorphic messages](#polymorphic-messages)
     - [Polymorphic producer](#polymorphic-producer)
     - [Polymorphic consumer](#polymorphic-consumer)
@@ -844,17 +847,84 @@ mbb.Consume<OrderEvent>(x =>
 
 ### Message Type Resolver
 
-By default, the message header `MessageType` conveys the message type information using the assembly qualified name of the .NET type (see `AssemblyQualifiedNameMessageTypeResolver`).
+SlimMessageBus uses the `MessageType` header to convey the message's type information as a `string`. This allows the consumer to determine the correct .NET `Type` needed to deserialize the payload.
 
-A custom resolver could be used. Some scenarios include a desire to send short type names (to optimize overall message size) or adjust interoperability with other messaging systems.
-The following can be used to provide a custom `IMessageTypeResolver` implementation:
+- **Producer Side:** Converts the `.NET Type` to a string and adds it to the message header.
+- **Consumer Side:** Reads the string from the header, resolves the corresponding `Type`, and passes it to the serializer to deserialize the message before handing it off to the appropriate handler.
 
-```cs
-IMessageTypeResolver mtr = new AssemblyQualifiedNameMessageTypeResolver();
+Type resolution is handled via the [`IMessageTypeResolver`](/src/SlimMessageBus.Host/MessageTypeResolver/IMessageTypeResolver.cs) interface, which is resolved from the dependency injection (DI) container.
+
+By default, SlimMessageBus registers the [`AssemblyQualifiedNameMessageTypeResolver`](/src/SlimMessageBus.Host/MessageTypeResolver/AssemblyQualifiedNameMessageTypeResolver.cs), which formats the type name as an **assembly-qualified name (without the version number)**. For example:
+
+```
+MyNamespace.MyMessage, MyAssembly
+```
+
+#### Custom Message Type Resolvers
+
+You can provide a custom implementation of `IMessageTypeResolver` to support scenarios like:
+
+- Reducing message size by using short or alias-based type names.
+- Integrating with other messaging systems using different naming conventions.
+- Supporting versioning or refactoring, such as type or namespace changes.
+
+**Example – Custom Resolver Registration**
+
+```csharp
+public class MyShortNameMessageTypeResolver : IMessageTypeResolver
+{
+    // Implement custom logic to map between Type and string.
+    // Useful for short names, legacy mappings, etc.
+}
+
+// Register with Microsoft DI
+services.AddSingleton<MyShortNameMessageTypeResolver>();
+
+services.AddSlimMessageBus(mbb =>
+{
+    // If this were to be a hybrid bus, each child bus can have its own type resolver
+    mbb.WithMessageTypeResolver<MyShortNameMessageTypeResolver>();
+});
+```
 
-mbb.WithMessageTypeResolver(mtr)
+#### Use Case: Type Redirection for Evolving Services
+
+Suppose you refactor a service, moving messages to a new assembly or namespace. Since producers and consumers may be deployed independently, you’ll need a strategy to handle message type mismatches between versions.
+
+With a custom resolver, you can:
+
+- **Redirect** incoming messages that reference old type names to the updated `Type`.
+- **Emit** legacy type names from the producer for backward compatibility.
+
+##### Using Redirects with the Default Resolver
+
+If you're using the default [`AssemblyQualifiedNameMessageTypeResolver`](/src/SlimMessageBus.Host/MessageTypeResolver/AssemblyQualifiedNameMessageTypeResolver.cs), you can extend it by implementing [`IAssemblyQualifiedNameMessageTypeResolverRedirect`](/src/SlimMessageBus.Host/MessageTypeResolver/IAssemblyQualifiedNameMessageTypeResolverRedirect.cs).
+
+```csharp
+public class MyTypeResolverRedirect : IAssemblyQualifiedNameMessageTypeResolverRedirect
+{
+    public Type TryGetType(string name)
+    {
+        if (name == "MyNamespace.MyMessage, MyAssembly")
+        {
+            return Type.GetType("NewNamespace.MyMessage, NewAssembly");
+            // or return typeof(MyMessage);
+        }
+        return null; // no match
+    }
+
+    public string TryGetName(Type messageType) => null; // No outgoing redirect
+}
 ```
 
+These redirect services must be registered with DI. You can register multiple for modularity:
+
+```csharp
+services.TryAddEnumerable<IAssemblyQualifiedNameMessageTypeResolverRedirect, MyTypeResolverRedirect>();
+```
+
+This makes it easy to maintain compatibility as your services evolve, without disrupting production systems.
+
 ### Polymorphic messages
 
 SMB supports working with message hierarchies.

src/SlimMessageBus.Host/MessageTypeResolver/AssemblyQualifiedNameMessageTypeResolver.cs

@@ -5,7 +5,7 @@
 using SlimMessageBus.Host.Collections;
 
 /// <summary>
-/// <see cref="IMessageTypeResolver"/> that uses the <see cref="Type.AssemblyQualifiedName"/> for the message type string passed in the message header.
+/// <see cref="IMessageTypeResolver"/> that uses the <see cref="Type.AssemblyQualifiedName"/> for mapping the <see cref="Type"/ to a string header value.
 /// </summary>
 public class AssemblyQualifiedNameMessageTypeResolver : IMessageTypeResolver
 {
@@ -16,32 +16,59 @@ public class AssemblyQualifiedNameMessageTypeResolver : IMessageTypeResolver
     /// </summary>
     public bool EmitAssemblyStrongName { get; set; } = false;
 
-    private readonly SafeDictionaryWrapper<Type, string> toNameCache;
-    private readonly SafeDictionaryWrapper<string, Type> toTypeCache;
+    private readonly SafeDictionaryWrapper<Type, string> _toNameCache;
+    private readonly SafeDictionaryWrapper<string, Type> _toTypeCache;
+    private readonly IAssemblyQualifiedNameMessageTypeResolverRedirect[] _items;
 
-    public AssemblyQualifiedNameMessageTypeResolver()
+    public AssemblyQualifiedNameMessageTypeResolver(IEnumerable<IAssemblyQualifiedNameMessageTypeResolverRedirect> items = null)
     {
-        toNameCache = new SafeDictionaryWrapper<Type, string>(ToNameInternal);
-        toTypeCache = new SafeDictionaryWrapper<string, Type>(ToTypeInternal);
+        _toNameCache = new SafeDictionaryWrapper<Type, string>(ToNameInternal);
+        _toTypeCache = new SafeDictionaryWrapper<string, Type>(ToTypeInternal);
+        _items = items is not null ? [.. items] : [];
     }
 
     private string ToNameInternal(Type messageType)
     {
-        var assemblyQualifiedName = messageType?.AssemblyQualifiedName ?? throw new ArgumentNullException(nameof(messageType));
+        if (messageType is null) throw new ArgumentNullException(nameof(messageType));
 
-        if (EmitAssemblyStrongName)
+        string assemblyQualifiedName = null;
+
+        foreach (var item in _items)
         {
-            return assemblyQualifiedName;
+            assemblyQualifiedName = item.TryGetName(messageType);
+            if (assemblyQualifiedName is not null)
+            {
+                break;
+            }
         }
 
-        var reducedName = RedundantAssemblyTokens.Replace(assemblyQualifiedName, string.Empty);
+        assemblyQualifiedName ??= messageType.AssemblyQualifiedName;
 
-        return reducedName;
+        if (!EmitAssemblyStrongName)
+        {
+            assemblyQualifiedName = RedundantAssemblyTokens.Replace(assemblyQualifiedName, string.Empty);
+        }
+
+        return assemblyQualifiedName;
     }
 
-    private Type ToTypeInternal(string name) => Type.GetType(name ?? throw new ArgumentNullException(nameof(name)));
+    private Type ToTypeInternal(string name)
+    {
+        if (name is null) throw new ArgumentNullException(nameof(name));
+
+        foreach (var item in _items)
+        {
+            var type = item.TryGetType(name);
+            if (type is not null)
+            {
+                return type;
+            }
+        }
+
+        return Type.GetType(name);
+    }
 
-    public string ToName(Type messageType) => toNameCache.GetOrAdd(messageType);
+    public string ToName(Type messageType) => _toNameCache.GetOrAdd(messageType);
 
-    public Type ToType(string name) => toTypeCache.GetOrAdd(name);
-}
+    public Type ToType(string name) => _toTypeCache.GetOrAdd(name);
+}

src/SlimMessageBus.Host/MessageTypeResolver/IAssemblyQualifiedNameMessageTypeResolverRedirect.cs

@@ -0,0 +1,18 @@
+namespace SlimMessageBus.Host;
+
+public interface IAssemblyQualifiedNameMessageTypeResolverRedirect
+{
+    /// <summary>
+    /// Returns the Type if it can be resolved for the name, otherwise null.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <returns></returns>
+    Type TryGetType(string name);
+
+    /// <summary>
+    /// Returns the name if it can be resolved for the type, otherwise null.
+    /// </summary>
+    /// <param name="messageType"></param>
+    /// <returns></returns>
+    string TryGetName(Type messageType);
+}

src/Tests/SlimMessageBus.Host.Test/MessageBusBaseTests.cs

@@ -28,7 +28,7 @@ public MessageBusBaseTests()
 
         _serviceProviderMock = new Mock<IServiceProvider>();
         _serviceProviderMock.Setup(x => x.GetService(typeof(IMessageSerializerProvider))).Returns(new JsonMessageSerializer());
-        _serviceProviderMock.Setup(x => x.GetService(typeof(IMessageTypeResolver))).Returns(new AssemblyQualifiedNameMessageTypeResolver());
+        _serviceProviderMock.Setup(x => x.GetService(typeof(IMessageTypeResolver))).Returns(new AssemblyQualifiedNameMessageTypeResolver([]));
         _serviceProviderMock.Setup(x => x.GetService(typeof(TimeProvider))).Returns(() => _timeProvider);
         _serviceProviderMock.Setup(x => x.GetService(It.Is<Type>(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>)))).Returns((Type t) => Array.CreateInstance(t.GetGenericArguments()[0], 0));
         _serviceProviderMock.Setup(x => x.GetService(typeof(RuntimeTypeCache))).Returns(new RuntimeTypeCache());

src/Tests/SlimMessageBus.Host.Test/MessageTypeResolver/AssemblyQualifiedNameMessageTypeResolverTests.cs

@@ -0,0 +1,45 @@
+namespace SlimMessageBus.Host.Test.MessageTypeResolver;
+
+public class AssemblyQualifiedNameMessageTypeResolverTests
+{
+    private readonly Mock<IAssemblyQualifiedNameMessageTypeResolverRedirect> _redirect;
+    private readonly AssemblyQualifiedNameMessageTypeResolver _subject;
+
+    public AssemblyQualifiedNameMessageTypeResolverTests()
+    {
+        _redirect = new Mock<IAssemblyQualifiedNameMessageTypeResolverRedirect>();
+        _subject = new AssemblyQualifiedNameMessageTypeResolver([_redirect.Object]);
+    }
+
+    [Theory]
+    [InlineData(typeof(SomeMessage), "SlimMessageBus.Host.Test.SomeMessage, SlimMessageBus.Host.Test")]
+    public void When_ToName_Given_TypeIsProvided_Then_AssemblyQualifiedNameIsReturned(Type messageType, string expectedName)
+    {
+        // Arrange
+        _redirect.Setup(x => x.TryGetName(messageType)).Returns(expectedName);
+
+        // Act
+        var result = _subject.ToName(messageType);
+
+        // Assert
+        result.Should().Be(expectedName);
+    }
+
+    [Theory]
+    [InlineData("SlimMessageBus.Host.Test.SomeMessage, SlimMessageBus.Host.Test", typeof(SomeMessage))]
+    [InlineData("SlimMessageBus.Host.Test.SomeMessageV1, SlimMessageBus.Host.Test", typeof(SomeMessage))]
+    [InlineData("SlimMessageBus.Host.Test.SomeMessage, SlimMessageBus.Host.V1", typeof(SomeMessage))]
+    public void When_ToType_Given_NameIsValid_Then_TypeIsReturned(string name, Type expectedMessageType)
+    {
+        // Arrange
+        _redirect.Setup(x => x.TryGetType("SlimMessageBus.Host.Test.SomeMessageV1, SlimMessageBus.Host.Test")).Returns(typeof(SomeMessage));
+        _redirect.Setup(x => x.TryGetType("SlimMessageBus.Host.Test.SomeMessage, SlimMessageBus.Host.V1")).Returns(typeof(SomeMessage));
+
+        // Act
+        var type = _subject.ToType(name);
+
+        // Assert
+        type.Should().Be(expectedMessageType);
+    }
+
+}