Extend PluginLoader

Author: StefH

WireMock.Net Solution.sln.DotSettings

@@ -23,6 +23,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=WWW/@EntryIndexedValue">WWW</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XMS/@EntryIndexedValue">XMS</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XUA/@EntryIndexedValue">XUA</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Dlls/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Flurl/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=funcs/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Grpc/@EntryIndexedValue">True</s:Boolean>

src/WireMock.Net/Plugin/PluginLoader.cs

@@ -1,56 +1,89 @@
 using System;
 using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using Stef.Validation;
 
 namespace WireMock.Plugin;
 
 internal static class PluginLoader
 {
-    private static readonly ConcurrentDictionary<Type, Type> Assemblies = new();
+    private static readonly ConcurrentDictionary<string, Type> Assemblies = new();
 
-    public static T Load<T>(params object[] args) where T : class
+    public static TInterface Load<TInterface>(params object[] args) where TInterface : class
     {
-        var foundType = Assemblies.GetOrAdd(typeof(T), (type) =>
+        var key = typeof(TInterface).FullName!;
+
+        var pluginType = Assemblies.GetOrAdd(key, _ =>
         {
-            var files = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.dll");
+            if (TryFindTypeInDlls<TInterface>(null, out var foundType))
+            {
+                return foundType;
+            }
+
+            throw new DllNotFoundException($"No dll found which implements Interface '{key}'.");
+        });
+
+        return (TInterface)Activator.CreateInstance(pluginType, args)!;
+    }
+
+    public static TInterface LoadByFullName<TInterface>(string implementationTypeFullName, params object[] args) where TInterface : class
+    {
+        Guard.NotNullOrEmpty(implementationTypeFullName);
+
+        var @interface = typeof(TInterface).FullName;
+        var key = $"{@interface}_{implementationTypeFullName}";
+
+        var pluginType = Assemblies.GetOrAdd(key, _ =>
+        {
+            if (TryFindTypeInDlls<TInterface>(implementationTypeFullName, out var foundType))
+            {
+                return foundType;
+            }
+
+            throw new DllNotFoundException($"No dll found which implements Interface '{@interface}' and has FullName '{implementationTypeFullName}'.");
+        });
 
-            Type? pluginType = null;
-            foreach (var file in files)
+        return (TInterface)Activator.CreateInstance(pluginType, args)!;
+    }
+
+    private static bool TryFindTypeInDlls<TInterface>(string? implementationTypeFullName, [NotNullWhen(true)] out Type? pluginType) where TInterface : class
+    {
+        foreach (var file in Directory.GetFiles(Directory.GetCurrentDirectory(), "*.dll"))
+        {
+            try
             {
-                try
+                var assembly = Assembly.Load(new AssemblyName
                 {
-                    var assembly = Assembly.Load(new AssemblyName
-                    {
-                        Name = Path.GetFileNameWithoutExtension(file)
-                    });
-
-                    pluginType = GetImplementationTypeByInterface<T>(assembly);
-                    if (pluginType != null)
-                    {
-                        break;
-                    }
-                }
-                catch
+                    Name = Path.GetFileNameWithoutExtension(file)
+                });
+
+                if (TryGetImplementationTypeByInterfaceAndOptionalFullName<TInterface>(assembly, implementationTypeFullName, out pluginType))
                 {
-                    // no-op: just try next .dll
+                    return true;
                 }
             }
-
-            if (pluginType != null)
+            catch
             {
-                return pluginType;
+                // no-op: just try next .dll
             }
+        }
 
-            throw new DllNotFoundException($"No dll found which implements type '{type}'");
-        });
-
-        return (T)Activator.CreateInstance(foundType, args);
+        pluginType = null;
+        return false;
     }
 
-    private static Type? GetImplementationTypeByInterface<T>(Assembly assembly)
+    private static bool TryGetImplementationTypeByInterfaceAndOptionalFullName<T>(Assembly assembly, string? implementationTypeFullName, [NotNullWhen(true)] out Type? type)
     {
-        return assembly.GetTypes().FirstOrDefault(t => typeof(T).IsAssignableFrom(t) && !t.GetTypeInfo().IsInterface);
+        type = assembly
+            .GetTypes()
+            .FirstOrDefault(t =>
+                typeof(T).IsAssignableFrom(t) && !t.GetTypeInfo().IsInterface &&
+                implementationTypeFullName == null || string.Equals(t.FullName, implementationTypeFullName, StringComparison.OrdinalIgnoreCase)
+            );
+
+        return type != null;
     }
 }

test/WireMock.Net.Tests/Plugin/PluginLoaderTests.cs

@@ -10,12 +10,20 @@ namespace WireMock.Net.Tests.Plugin;
 
 public class PluginLoaderTests
 {
-    public interface IDummy
+    public interface IDummyInterfaceNoImplementation
+    {
+    }
+
+    public interface IDummyInterfaceWithImplementation
+    {
+    }
+
+    public class DummyClass : IDummyInterfaceWithImplementation
     {
     }
 
     [Fact]
-    public void Load_Valid()
+    public void Load_ByInterface()
     {
         // Act
         AnyOf<string, StringPattern> pattern = "x";
@@ -26,12 +34,32 @@ public void Load_Valid()
     }
 
     [Fact]
-    public void Load_Invalid_ThrowsException()
+    public void Load_ByInterfaceAndFullName()
+    {
+        // Act
+        var result = PluginLoader.LoadByFullName<IDummyInterfaceWithImplementation>(typeof(DummyClass).FullName);
+
+        // Assert
+        result.Should().BeOfType<DummyClass>();
+    }
+
+    [Fact]
+    public void Load_ByInterface_ButNoImplementationFoundForInterface_ThrowsException()
+    {
+        // Act
+        Action a = () => PluginLoader.Load<IDummyInterfaceNoImplementation>();
+
+        // Assert
+        a.Should().Throw<DllNotFoundException>().WithMessage("No dll found which implements Interface 'WireMock.Net.Tests.Plugin.PluginLoaderTests+IDummyInterfaceNoImplementation'.");
+    }
+
+    [Fact]
+    public void Load_ByInterfaceAndFullName_ButNoImplementationFoundForInterface_ThrowsException()
     {
         // Act
-        Action a = () => PluginLoader.Load<IDummy>();
+        Action a = () => PluginLoader.LoadByFullName<IDummyInterfaceWithImplementation>("xyz");
 
         // Assert
-        a.Should().Throw<DllNotFoundException>();
+        a.Should().Throw<DllNotFoundException>().WithMessage("No dll found which implements Interface 'WireMock.Net.Tests.Plugin.PluginLoaderTests+IDummyInterfaceWithImplementation' and has FullName 'xyz'.");
     }
 }