Add MessageUtil.GetTypeIdSkipCache

src/Abc.Zebus.Tests/MessageUtilTests.cs

@@ -94,7 +94,6 @@ namespace Abc.Zebus.Tests
         {
             var typeA = GenerateType(true);
             var typeB = GenerateType(false);
-
             typeB.FullName.ShouldEqual(typeA.FullName);
 
             MessageUtil.RegisterMessageType(typeA);
@@ -102,23 +101,38 @@ namespace Abc.Zebus.Tests
 
             MessageUtil.RegisterMessageType(typeB);
             new MessageTypeId(typeB).IsPersistent().ShouldBeFalse();
+        }
+
+        [Test]
+        public void should_load_message_type_id_without_cache()
+        {
+            var typeA = GenerateType(true);
+            var typeB = GenerateType(false);
+            typeB.FullName.ShouldEqual(typeA.FullName);
+
+            // Cached
+            MessageUtil.GetTypeId(typeA).IsPersistent().ShouldEqual(MessageUtil.GetTypeId(typeB).IsPersistent());
 
-            static Type GenerateType(bool persistent)
-            {
-                var moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString("N")), AssemblyBuilderAccess.Run)
-                                                   .DefineDynamicModule("Main");
+            // Uncached
+            MessageUtil.GetTypeIdSkipCache(typeA).IsPersistent().ShouldBeTrue();
+            MessageUtil.GetTypeIdSkipCache(typeB).IsPersistent().ShouldBeFalse();
+        }
+
+        private static Type GenerateType(bool persistent)
+        {
+            var moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString("N")), AssemblyBuilderAccess.Run)
+                                               .DefineDynamicModule("Main");
 
-                var typeBuilder = moduleBuilder.DefineType(
-                    "GeneratedMessageType",
-                    TypeAttributes.AutoClass | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit | TypeAttributes.Class | TypeAttributes.NotPublic | TypeAttributes.Sealed,
-                    typeof(object)
-                );
+            var typeBuilder = moduleBuilder.DefineType(
+                "GeneratedMessageType",
+                TypeAttributes.AutoClass | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit | TypeAttributes.Class | TypeAttributes.NotPublic | TypeAttributes.Sealed,
+                typeof(object)
+            );
 
-                if (!persistent)
-                    typeBuilder.SetCustomAttribute(new CustomAttributeBuilder(typeof(TransientAttribute).GetConstructor(Type.EmptyTypes), Array.Empty<object>()));
+            if (!persistent)
+                typeBuilder.SetCustomAttribute(new CustomAttributeBuilder(typeof(TransientAttribute).GetConstructor(Type.EmptyTypes), Array.Empty<object>()));
 
-                return typeBuilder.CreateType();
-            }
+            return typeBuilder.CreateType();
         }
 
         public class GenericEvent<T> : IEvent

src/Abc.Zebus/MessageTypeDescriptor.cs

@@ -48,7 +48,14 @@ namespace Abc.Zebus
             if (fullName == null)
                 return Null;
 
-            var messageType = TypeUtil.Resolve(fullName);
+            return Load(TypeUtil.Resolve(fullName), fullName);
+        }
+
+        internal static MessageTypeDescriptor Load(Type? messageType, string? fullName)
+        {
+            if (fullName == null)
+                return Null;
+
             if (messageType == null)
                 return new MessageTypeDescriptor(fullName);
 

src/Abc.Zebus/MessageTypeDescriptorCache.cs

@@ -33,6 +33,14 @@ namespace Abc.Zebus
             return _descriptorsByType.GetOrAdd(messageType, _loadDescriptorFromType);
         }
 
+        internal static MessageTypeDescriptor GetMessageTypeDescriptorSkipCache(Type? messageType)
+        {
+            if (messageType == null)
+                return MessageTypeDescriptor.Null;
+
+            return MessageTypeDescriptor.Load(messageType, TypeUtil.GetFullNameWithNoAssemblyOrVersion(messageType));
+        }
+
         private static MessageTypeDescriptor LoadMessageTypeDescriptor(Type? messageType)
         {
             if (messageType == null)

src/Abc.Zebus/MessageTypeId.cs

@@ -14,9 +14,14 @@ namespace Abc.Zebus
 
         private readonly MessageTypeDescriptor? _descriptor;
 
-        public MessageTypeId(Type? messageType) => _descriptor = MessageTypeDescriptorCache.GetMessageTypeDescriptor(messageType);
+        public MessageTypeId(Type? messageType)
+            => _descriptor = MessageTypeDescriptorCache.GetMessageTypeDescriptor(messageType);
 
-        public MessageTypeId(string? fullName) => _descriptor = MessageTypeDescriptorCache.GetMessageTypeDescriptor(fullName);
+        public MessageTypeId(string? fullName)
+            => _descriptor = MessageTypeDescriptorCache.GetMessageTypeDescriptor(fullName);
+
+        private MessageTypeId(MessageTypeDescriptor descriptor)
+            => _descriptor = descriptor;
 
         public string? FullName => Descriptor.FullName;
 
@@ -40,6 +45,9 @@ namespace Abc.Zebus
             return lastDotIndex != -1 ? FullName.Substring(lastDotIndex + 1) : FullName;
         }
 
+        internal static MessageTypeId GetMessageTypeIdSkipCache(Type? messageType)
+            => new MessageTypeId(MessageTypeDescriptorCache.GetMessageTypeDescriptorSkipCache(messageType));
+
         public bool Equals(MessageTypeId other) => _descriptor == other._descriptor;
         public override bool Equals(object? obj) => obj is MessageTypeId messageTypeId && Equals(messageTypeId);
 
@@ -56,9 +64,7 @@ namespace Abc.Zebus
             private string? FullName { get; set; }
 
             private ProtobufSurrogate(MessageTypeId typeId)
-            {
-                FullName = typeId.FullName;
-            }
+                => FullName = typeId.FullName;
 
             public static implicit operator MessageTypeId(ProtobufSurrogate value) => new MessageTypeId(value.FullName);
             public static implicit operator ProtobufSurrogate(MessageTypeId value) => new ProtobufSurrogate(value);

src/Abc.Zebus/MessageUtil.cs

@@ -5,20 +5,18 @@ namespace Abc.Zebus
 {
     public static class MessageUtil
     {
-        public static MessageTypeId TypeId<T>() where T : IMessage
-        {
-            return GetTypeId(typeof(T));
-        }
+        public static MessageTypeId TypeId<T>()
+            where T : IMessage
+            => GetTypeId(typeof(T));
 
         public static MessageTypeId TypeId(this IMessage message)
-        {
-            return GetTypeId(message.GetType());
-        }
+            => GetTypeId(message.GetType());
 
         public static MessageTypeId GetTypeId(Type messageType)
-        {
-            return new MessageTypeId(messageType);
-        }
+            => new MessageTypeId(messageType);
+
+        public static MessageTypeId GetTypeIdSkipCache(Type messageType)
+            => MessageTypeId.GetMessageTypeIdSkipCache(messageType);
 
         /// <summary>
         /// Useful for advanced scenarios where a given type name is loaded multiple times.