Add Keyed Service name support

src/Scrutor/IImplementationTypeFilter.cs

@@ -32,6 +32,12 @@ public interface IImplementationTypeFilter : IFluentInterface
     /// <exception cref="ArgumentNullException">If the <paramref name="types"/> argument is <c>null</c>.</exception>
     IImplementationTypeFilter AssignableToAny(IEnumerable<Type> types);
 
+    /// <summary>
+    /// Will match all types that are assignable to ServiceKeyAttribute />.
+    /// </summary>
+    /// <returns></returns>
+    IImplementationTypeFilter WithKeyName();
+
     /// <summary>
     /// Will match all types that has an attribute of type <typeparamref name="T"/> defined.
     /// </summary>

src/Scrutor/ImplementationTypeFilter.cs

@@ -42,6 +42,10 @@ public IImplementationTypeFilter AssignableToAny(IEnumerable<Type> types)
         return Where(t => types.Any(t.IsBasedOn));
     }
 
+
+    public IImplementationTypeFilter WithKeyName()
+        => WithAttribute<ServiceKeyAttribute>();
+
     public IImplementationTypeFilter WithAttribute<T>() where T : Attribute
     {
         return WithAttribute(typeof(T));
@@ -52,7 +56,7 @@ public IImplementationTypeFilter WithAttribute(Type attributeType)
         Preconditions.NotNull(attributeType, nameof(attributeType));
 
         IncludeCompilerGeneratedTypes |= attributeType == typeof(CompilerGeneratedAttribute);
-        return Where(t => t.HasAttribute(attributeType));
+        return Where(t => t.HasAttribute(attributeType) );
     }
 
     public IImplementationTypeFilter WithAttribute<T>(Func<T, bool> predicate) where T : Attribute

src/Scrutor/LifetimeSelector.cs

@@ -245,7 +245,11 @@ void ISelector.Populate(IServiceCollection services, RegistrationStrategy? strat
 
                 var lifetime = GetOrAddLifetime(lifetimes, implementationType);
 
-                var descriptor = new ServiceDescriptor(serviceType, implementationType, lifetime);
+                ServiceKeyAttribute? attr = implementationType.GetCustomAttribute<ServiceKeyAttribute>();
+
+                ServiceDescriptor descriptor = attr != null
+                                ? new ServiceDescriptor(serviceType, attr.Name, implementationType, lifetime)
+                                : new ServiceDescriptor(serviceType, implementationType, lifetime);
 
                 strategy.Apply(services, descriptor);
             }

src/Scrutor/Scrutor.csproj

@@ -7,7 +7,7 @@
     <NoWarn>$(NoWarn);CS1591</NoWarn>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageId>Scrutor</PackageId>
     <PackageTags>Dependency;Injection;DI;Scanning;Conventions;Decoration</PackageTags>

src/Scrutor/ServiceKeyAttribute.cs

@@ -0,0 +1,11 @@
+using JetBrains.Annotations;
+using System;
+
+namespace Scrutor;
+
+[PublicAPI]
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+public sealed class ServiceKeyAttribute(string name): Attribute
+{
+    public string Name { get; } = name ?? throw new ArgumentNullException(nameof(name));
+}

test/Scrutor.Tests/ScanningTests.cs

@@ -584,10 +584,35 @@ public void ShouldAllowOptInToCompilerGeneratedTypes()
                     .AsSelf()
                     .WithTransientLifetime());
             });
-            
+
             var compilerGeneratedSubclass = provider.GetService<AllowedCompilerGeneratedSubclass>();
             Assert.NotNull(compilerGeneratedSubclass);
         }
+
+
+        [Fact]
+        public void KeyedTransientService()
+        {
+            ServiceProvider provider = ConfigureProvider(services =>
+            {
+                services.Scan(scan => scan
+                    .FromAssemblyOf<INamedService>()
+                    .AddClasses(classes => classes.AssignableTo<INamedService>())
+                    .AsImplementedInterfaces()
+                    .WithTransientLifetime());
+
+                var namedServices = services.GetDescriptors<INamedService>();
+
+                Assert.Equal(2, namedServices.Count(x => x.ServiceType == typeof(INamedService)));
+            });
+
+            var transientKeyedService1 = provider.GetKeyedService<INamedService>("t1");
+            Assert.NotNull(transientKeyedService1);
+
+            var transientKeyedService2 = provider.GetKeyedService<INamedService>("t1");
+            Assert.NotNull(transientKeyedService2);
+
+        }
     }
 
     // ReSharper disable UnusedTypeParameter
@@ -597,6 +622,7 @@ public interface ITransientService { }
     [ServiceDescriptor(typeof(ITransientService))]
     public class TransientService1 : ITransientService { }
 
+
     public class TransientService2 : ITransientService, IOtherInheritance { }
 
     public class TransientService : ITransientService, IEnumerable<string>
@@ -671,7 +697,7 @@ public class DefaultAttributes : IDefault3Level2, IDefault1, IDefault2 { }
     [CompilerGenerated]
     public class CompilerGenerated { }
 
-    public class CombinedService2: IDefault1, IDefault2, IDefault3Level2 { }
+    public class CombinedService2 : IDefault1, IDefault2, IDefault3Level2 { }
 
     public interface IGenericAttribute { }
 
@@ -688,6 +714,15 @@ public abstract class AllowedCompilerGeneratedBase { }
 
     [CompilerGenerated]
     public class AllowedCompilerGeneratedSubclass : AllowedCompilerGeneratedBase { }
+
+
+    public interface INamedService { }
+
+    [ServiceKey("t1")]
+    public class NameService1 : INamedService { }
+
+    [ServiceKey("t2")]
+    public class NameService2 : INamedService { }
 }
 
 namespace Scrutor.Tests.ChildNamespace