Update to .NET 8 and leverage keyed services for decoration

.github/workflows/build.yml

@@ -14,17 +14,13 @@ jobs:
 
         steps:
             - name: Checkout
-              uses: actions/checkout@v2
+              uses: actions/checkout@v3
 
-            - name: Setup .NET Core SDK
-              uses: actions/setup-dotnet@v1
+            - name: Setup .NET 8 SDK
+              uses: actions/setup-dotnet@v3
               with:
-                  dotnet-version: "3.1.x"
-
-            - name: Setup .NET 7 SDK
-              uses: actions/setup-dotnet@v1
-              with:
-                  dotnet-version: "7.0.x"
+                  dotnet-version: "8.x"
+                  dotnet-quality: "preview"
 
             - name: Test
               run: dotnet test --collect:"XPlat Code Coverage"

NuGet.Config

@@ -3,5 +3,6 @@
 <configuration>
     <packageSources>
         <add key="api.nuget.org" value="https://api.nuget.org/v3/index.json" />
+        <add key="dotnet8" value="https://dnceng.pkgs.visualstudio.com/public/_packaging/dotnet8/nuget/v3/index.json" />
     </packageSources>
 </configuration>

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)
     {
@@ -49,4 +49,4 @@ private static IEnumerable<ServiceDescriptorAttribute> GetDuplicates(IEnumerable
     {
         return attributes.GroupBy(s => s.ServiceType).SelectMany(grp => grp.Skip(1));
     }
-}
+}

src/Scrutor/ClosedTypeDecorationStrategy.cs

@@ -4,7 +4,7 @@ namespace Scrutor;
 
 internal sealed class ClosedTypeDecorationStrategy : DecorationStrategy
 {
-    public ClosedTypeDecorationStrategy(Type serviceType, Type? decoratorType, Func<object, IServiceProvider, object>? decoratorFactory) : base(serviceType)
+    public ClosedTypeDecorationStrategy(Type serviceType, string? serviceKey, Type? decoratorType, Func<object, IServiceProvider, object>? decoratorFactory) : base(serviceType, serviceKey)
     {
         DecoratorType = decoratorType;
         DecoratorFactory = decoratorFactory;
@@ -14,20 +14,20 @@ public ClosedTypeDecorationStrategy(Type serviceType, Type? decoratorType, Func<
 
     private Func<object, IServiceProvider, object>? DecoratorFactory { get; }
 
-    public override bool CanDecorate(Type serviceType) => ServiceType == serviceType;
+    protected override bool CanDecorate(Type serviceType) => ServiceType == serviceType;
 
-    public override Func<IServiceProvider, object> CreateDecorator(Type serviceType)
+    public override Func<IServiceProvider, object?, object> CreateDecorator(Type serviceType, string serviceKey)
     {
         if (DecoratorType is not null)
         {
-            return TypeDecorator(serviceType, DecoratorType);
+            return TypeDecorator(serviceType, serviceKey, DecoratorType);
         }
 
         if (DecoratorFactory is not null)
         {
-            return FactoryDecorator(serviceType, DecoratorFactory);
+            return FactoryDecorator(serviceType, serviceKey, DecoratorFactory);
         }
 
-        throw new InvalidOperationException($"Both serviceType and decoratorFactory can not be null.");
-    } 
+        throw new InvalidOperationException($"Both {nameof(DecoratorType)} and {nameof(DecoratorFactory)} can not be null.");
+    }
 }

src/Scrutor/DecorationException.cs

@@ -6,6 +6,6 @@ public DecorationException(DecorationStrategy strategy) : base(strategy.ServiceT
     {
         Strategy = strategy;
     }
-    
+
     public DecorationStrategy Strategy { get; }
 }

src/Scrutor/DecorationStrategy.cs

@@ -5,42 +5,52 @@ namespace Scrutor;
 
 public abstract class DecorationStrategy
 {
-    protected DecorationStrategy(Type serviceType)
+    protected DecorationStrategy(Type serviceType, string? serviceKey)
     {
         ServiceType = serviceType;
+        ServiceKey = serviceKey;
     }
-    
+
     public Type ServiceType { get; }
-
-    public abstract bool CanDecorate(Type serviceType);
-
-    public abstract Func<IServiceProvider, object> CreateDecorator(Type serviceType);
-
-    internal static DecorationStrategy WithType(Type serviceType, Type decoratorType) => 
-        Create(serviceType, decoratorType, decoratorFactory: null);
-
-    internal static DecorationStrategy WithFactory(Type serviceType, Func<object, IServiceProvider, object> decoratorFactory) => 
-        Create(serviceType, decoratorType: null, decoratorFactory);
-
-    protected static Func<IServiceProvider, object> TypeDecorator(Type serviceType, Type decoratorType) => serviceProvider =>
+
+    public string? ServiceKey { get; }
+
+    public virtual bool CanDecorate(ServiceDescriptor descriptor) =>
+        string.Equals(ServiceKey, descriptor.ServiceKey) && CanDecorate(descriptor.ServiceType);
+
+    protected abstract bool CanDecorate(Type serviceType);
+
+    public abstract Func<IServiceProvider, object?, object> CreateDecorator(Type serviceType, string serviceKey);
+
+    internal static DecorationStrategy WithType(Type serviceType, string? serviceKey, Type decoratorType) =>
+        Create(serviceType, serviceKey, decoratorType, decoratorFactory: null);
+
+    internal static DecorationStrategy WithFactory(Type serviceType, string? serviceKey, Func<object, IServiceProvider, object> decoratorFactory) =>
+        Create(serviceType, serviceKey, decoratorType: null, decoratorFactory);
+
+    protected static Func<IServiceProvider, object?, object> TypeDecorator(Type serviceType, string serviceKey, Type decoratorType)
     {
-        var instanceToDecorate = serviceProvider.GetRequiredService(serviceType);
-        return ActivatorUtilities.CreateInstance(serviceProvider, decoratorType, instanceToDecorate);
-    };
+        var factory = ActivatorUtilities.CreateFactory(decoratorType, new[] { serviceType });
+        return (serviceProvider, _) =>
+        {
+            var instanceToDecorate = serviceProvider.GetRequiredKeyedService(serviceType, serviceKey);
+            return factory(serviceProvider, new object[] { instanceToDecorate });
+        };
+    }
 
-    protected static Func<IServiceProvider, object> FactoryDecorator(Type decorated, Func<object, IServiceProvider, object> decoratorFactory) => serviceProvider =>
+    protected static Func<IServiceProvider, object?, object> FactoryDecorator(Type serviceType, string serviceKey, Func<object, IServiceProvider, object> decoratorFactory) => (serviceProvider, _) =>
     {
-        var instanceToDecorate = serviceProvider.GetRequiredService(decorated);
+        var instanceToDecorate = serviceProvider.GetRequiredKeyedService(serviceType, serviceKey);
         return decoratorFactory(instanceToDecorate, serviceProvider);
     };
 
-    private static DecorationStrategy Create(Type serviceType, Type? decoratorType, Func<object, IServiceProvider, object>? decoratorFactory)
+    private static DecorationStrategy Create(Type serviceType, string? serviceKey, Type? decoratorType, Func<object, IServiceProvider, object>? decoratorFactory)
     {
         if (serviceType.IsOpenGeneric())
         {
-            return new OpenGenericDecorationStrategy(serviceType, decoratorType, decoratorFactory);
+            return new OpenGenericDecorationStrategy(serviceType, serviceKey, decoratorType, decoratorFactory);
         }
 
-        return new ClosedTypeDecorationStrategy(serviceType, decoratorType, decoratorFactory);
+        return new ClosedTypeDecorationStrategy(serviceType, serviceKey, decoratorType, decoratorFactory);
     }
 }

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/IAssemblySelector.cs

@@ -95,4 +95,4 @@ public interface IAssemblySelector : IFluentInterface
     /// <param name="assemblies">The assemblies to should be scanned.</param>
     /// <exception cref="ArgumentNullException">If the <paramref name="assemblies"/> argument is <c>null</c>.</exception>
     IImplementationTypeSelector FromAssemblies(IEnumerable<Assembly> assemblies);
-}
+}

src/Scrutor/IFluentInterface.cs

@@ -17,4 +17,4 @@ public interface IFluentInterface
 
     [EditorBrowsable(EditorBrowsableState.Never)]
     bool Equals(object? obj);
-}
+}

src/Scrutor/IImplementationTypeFilter.cs

@@ -155,4 +155,4 @@ public interface IImplementationTypeFilter : IFluentInterface
     /// <param name="predicate">The predicate to match types.</param>
     /// <exception cref="ArgumentNullException">If the <paramref name="predicate" /> argument is <c>null</c>.</exception>
     IImplementationTypeFilter Where(Func<Type, bool> predicate);
-}
+}

src/Scrutor/IImplementationTypeSelector.cs

@@ -33,4 +33,4 @@ public interface IImplementationTypeSelector : IAssemblySelector
     /// <exception cref="ArgumentNullException">If the <paramref name="action"/> argument is <c>null</c>.</exception>
     /// <param name="publicOnly">Specifies whether too add public types only.</param>
     IServiceTypeSelector AddClasses(Action<IImplementationTypeFilter> action, bool publicOnly);
-}
+}

src/Scrutor/ILifetimeSelector.cs

@@ -23,4 +23,4 @@ public interface ILifetimeSelector : IServiceTypeSelector
     /// Registers each matching concrete type with the specified <paramref name="lifetime"/>.
     /// </summary>
     IImplementationTypeSelector WithLifetime(ServiceLifetime lifetime);
-}
+}

src/Scrutor/ISelector.cs

@@ -5,4 +5,4 @@ namespace Scrutor;
 public interface ISelector
 {
     void Populate(IServiceCollection services, RegistrationStrategy? options);
-}
+}