Use sets internally to avoid duplicate types and assemblies

src/Scrutor/AttributeSelector.cs

@@ -8,12 +8,12 @@ namespace Scrutor;
 
 internal class AttributeSelector : ISelector
 {
-    public AttributeSelector(IEnumerable<Type> types)
+    public AttributeSelector(ISet<Type> types)
     {
         Types = types;
     }
 
-    private IEnumerable<Type> Types { get; }
+    private ISet<Type> Types { get; }
 
     void ISelector.Populate(IServiceCollection services, RegistrationStrategy? registrationStrategy)
     {

src/Scrutor/EnumerableExtensions.cs

@@ -0,0 +1,20 @@
+#if !NET8_0_OR_GREATER
+
+using System.Collections.Generic;
+
+namespace Scrutor;
+
+internal static class EnumerableExtensions
+{
+    public static ISet<T> ToHashSet<T>(this IEnumerable<T> source)
+    {
+        if (source is ISet<T> set)
+        {
+            return set;
+        }
+
+        return new HashSet<T>(source);
+    }
+}
+
+#endif

src/Scrutor/ImplementationTypeFilter.cs

@@ -6,12 +6,12 @@ namespace Scrutor;
 
 internal class ImplementationTypeFilter : IImplementationTypeFilter
 {
-    public ImplementationTypeFilter(IEnumerable<Type> types)
+    public ImplementationTypeFilter(ISet<Type> types)
     {
         Types = types;
     }
 
-    internal IEnumerable<Type> Types { get; private set; }
+    internal ISet<Type> Types { get; private set; }
 
     public IImplementationTypeFilter AssignableTo<T>()
     {
@@ -151,7 +151,7 @@ public IImplementationTypeFilter Where(Func<Type, bool> predicate)
     {
         Preconditions.NotNull(predicate, nameof(predicate));
 
-        Types = Types.Where(predicate);
+        Types.IntersectWith(Types.Where(predicate));
         return this;
     }
 }

src/Scrutor/ImplementationTypeSelector.cs

@@ -9,15 +9,15 @@ namespace Scrutor;
 
 internal class ImplementationTypeSelector : IImplementationTypeSelector, ISelector
 {
-    public ImplementationTypeSelector(ITypeSourceSelector inner, IEnumerable<Type> types)
+    public ImplementationTypeSelector(ITypeSourceSelector inner, ISet<Type> types)
     {
         Inner = inner;
         Types = types;
     }
 
     private ITypeSourceSelector Inner { get; }
 
-    private IEnumerable<Type> Types { get; }
+    private ISet<Type> Types { get; }
 
     private List<ISelector> Selectors { get; } = new();
 
@@ -135,15 +135,15 @@ void ISelector.Populate(IServiceCollection services, RegistrationStrategy? regis
 
     private IServiceTypeSelector AddSelector(IEnumerable<Type> types)
     {
-        var selector = new ServiceTypeSelector(this, types);
+        var selector = new ServiceTypeSelector(this, types.ToHashSet());
 
         Selectors.Add(selector);
 
         return selector;
     }
 
-    private IEnumerable<Type> GetNonAbstractClasses(bool publicOnly)
+    private ISet<Type> GetNonAbstractClasses(bool publicOnly)
     {
-        return Types.Where(t => t.IsNonAbstractClass(publicOnly));
+        return Types.Where(t => t.IsNonAbstractClass(publicOnly)).ToHashSet();
     }
 }

src/Scrutor/ReflectionExtensions.cs

@@ -143,9 +143,9 @@ public static IEnumerable<Type> FindMatchingInterface(this Type type, Action<Typ
 
         var matchedInterfaces = GetImplementedInterfacesToMap(type)
             .Where(x => string.Equals(x.Name, matchingInterfaceName, StringComparison.Ordinal))
-            .ToArray();
+            .ToHashSet();
 
-        if (matchedInterfaces.Length == 0)
+        if (matchedInterfaces.Count == 0)
         {
             yield break;
         }

src/Scrutor/ServiceTypeSelector.cs

@@ -9,15 +9,15 @@ namespace Scrutor;
 
 internal class ServiceTypeSelector : IServiceTypeSelector, ISelector
 {
-    public ServiceTypeSelector(IImplementationTypeSelector inner, IEnumerable<Type> types)
+    public ServiceTypeSelector(IImplementationTypeSelector inner, ISet<Type> types)
     {
         Inner = inner;
         Types = types;
     }
 
     private IImplementationTypeSelector Inner { get; }
 
-    private IEnumerable<Type> Types { get; }
+    private ISet<Type> Types { get; }
 
     private List<ISelector> Selectors { get; } = new();
 

src/Scrutor/TypeSourceSelector.cs

@@ -71,7 +71,8 @@ public IImplementationTypeSelector FromDependencyContext(DependencyContext conte
         Preconditions.NotNull(predicate, nameof(predicate));
 
         var assemblyNames = context.RuntimeLibraries
-            .SelectMany(library => library.GetDefaultAssemblyNames(context));
+            .SelectMany(library => library.GetDefaultAssemblyNames(context))
+            .ToHashSet();
 
         var assemblies = LoadAssemblies(assemblyNames);
 
@@ -82,19 +83,21 @@ public IImplementationTypeSelector FromAssemblyDependencies(Assembly assembly)
     {
         Preconditions.NotNull(assembly, nameof(assembly));
 
-        var assemblies = new List<Assembly> { assembly };
-
         try
         {
-            var dependencyNames = assembly.GetReferencedAssemblies();
+            var dependencyNames = assembly
+                .GetReferencedAssemblies()
+                .ToHashSet();
+
+            var assemblies = LoadAssemblies(dependencyNames);
 
-            assemblies.AddRange(LoadAssemblies(dependencyNames));
+            assemblies.Add(assembly);
 
             return InternalFromAssemblies(assemblies);
         }
         catch
         {
-            return InternalFromAssemblies(assemblies);
+            return FromAssemblies(assembly);
         }
     }
 
@@ -132,11 +135,7 @@ public IServiceTypeSelector FromTypes(IEnumerable<Type> types)
     {
         Preconditions.NotNull(types, nameof(types));
 
-        var selector = new ImplementationTypeSelector(this, types);
-
-        Selectors.Add(selector);
-
-        return selector.AddClasses();
+        return AddSelector(types).AddClasses();
     }
 
     public void Populate(IServiceCollection services, RegistrationStrategy? registrationStrategy)
@@ -154,12 +153,12 @@ private IImplementationTypeSelector InternalFromAssembliesOf(IEnumerable<Type> t
 
     private IImplementationTypeSelector InternalFromAssemblies(IEnumerable<Assembly> assemblies)
     {
-        return AddSelector(assemblies.SelectMany(asm => asm.DefinedTypes).Select(x => x.AsType()));
+        return AddSelector(assemblies.SelectMany(asm => asm.GetTypes()));
     }
 
-    private static IEnumerable<Assembly> LoadAssemblies(IEnumerable<AssemblyName> assemblyNames)
+    private static ISet<Assembly> LoadAssemblies(ISet<AssemblyName> assemblyNames)
     {
-        var assemblies = new List<Assembly>();
+        var assemblies = new HashSet<Assembly>();
 
         foreach (var assemblyName in assemblyNames)
         {
@@ -179,7 +178,7 @@ private static IEnumerable<Assembly> LoadAssemblies(IEnumerable<AssemblyName> as
 
     private IImplementationTypeSelector AddSelector(IEnumerable<Type> types)
     {
-        var selector = new ImplementationTypeSelector(this, types);
+        var selector = new ImplementationTypeSelector(this, types.ToHashSet());
 
         Selectors.Add(selector);