refactor: update _namespaces_, and cache so that we don't have to repeat the lookup logic over and over

Author: the-avid-engineer

src/EntityDb.Common/TypeResolvers/DefaultPartialTypeResolver.cs

@@ -8,6 +8,7 @@ namespace EntityDb.Common.TypeResolvers;
 internal sealed class DefaultPartialTypeResolver : IPartialTypeResolver
 {
     private readonly IOptions<DefaultPartialTypeResolverOptions> _options;
+    private readonly Dictionary<string, Type> _cache = new();
 
     public DefaultPartialTypeResolver(IOptions<DefaultPartialTypeResolverOptions> options)
     {
@@ -24,30 +25,59 @@ public bool TryResolveType(EnvelopeHeaders envelopeHeaders, [NotNullWhen(true)]
             return false;
         }
 
-        resolvedType = Type.GetType
-        (
-            Assembly.CreateQualifiedName(assemblyFullName, typeFullName),
-            AssemblyResolver,
-            (assembly, typeName, ignoreCase) => assembly!.GetType(typeName, true, ignoreCase),
-            true,
-            false
-        )!;
+        var qualifiedTypeName = Assembly.CreateQualifiedName(assemblyFullName, typeFullName);
+
+        if (_cache.TryGetValue(qualifiedTypeName, out resolvedType))
+        {
+            return true;
+        }
+
+        if (!TryGetType(qualifiedTypeName, out resolvedType))
+        {
+            return false;
+        }
+
+        _cache.Add(qualifiedTypeName, resolvedType);
 
         return true;
     }
 
-    private Assembly AssemblyResolver(AssemblyName assemblyName)
+    private bool TryGetType(string qualifiedTypeName, [NotNullWhen(true)] out Type? resolvedType)
     {
-        if (assemblyName.Name is { } originalName && _options.Value.UpdateNames.TryGetValue(originalName, out var newName))
+        foreach (var (oldNamespace, newNamespace) in _options.Value.UpdateNamespaces)
         {
-            assemblyName.Name = newName;
+            qualifiedTypeName = qualifiedTypeName.Replace(oldNamespace, newNamespace);
         }
 
+        resolvedType = Type.GetType
+        (
+            qualifiedTypeName,
+            AssemblyResolver,
+            TypeResolver,
+            _options.Value.ThrowOnError,
+            _options.Value.IgnoreCase
+        );
+
+        return resolvedType is not null;
+    }
+
+    private Assembly AssemblyResolver(AssemblyName assemblyName)
+    {
         if (_options.Value.IgnoreVersion)
         {
             assemblyName.Version = null;
         }
 
         return Assembly.Load(assemblyName);
     }
+
+    private Type? TypeResolver(Assembly? assembly, string typeName, bool ignoreCase)
+    {
+        return assembly?.GetType
+        (
+            typeName,
+            _options.Value.ThrowOnError,
+            ignoreCase
+        );
+    }
 }

src/EntityDb.Common/TypeResolvers/DefaultPartialTypeResolverOptions.cs

@@ -5,12 +5,22 @@ namespace EntityDb.Common.TypeResolvers;
 /// </summary>
 public sealed class DefaultPartialTypeResolverOptions
 {
+    /// <summary>
+    ///     Throw an exception if the type cannot be resolved.
+    /// </summary>
+    public bool ThrowOnError { get; set; } = true;
+
+    /// <summary>
+    ///     Perform a case-insensitive search for the type name.
+    /// </summary>
+    public bool IgnoreCase { get; set; } = false;
+    
     /// <summary>
     ///     If you rename your assemblies, you will want to update the
     ///     name of the assembly for type resolving purposes, at least
     ///     until you update the data header.
     /// </summary>
-    public Dictionary<string, string> UpdateNames { get; set; } = new();
+    public Dictionary<string, string> UpdateNamespaces { get; set; } = new();
 
     /// <summary>
     ///     If you version your assemblies, you may want to ignore the