Support Keyed Services in MVC

src/Mvc/Mvc.Abstractions/src/ModelBinding/BindingInfo.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using Microsoft.AspNetCore.Mvc.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.AspNetCore.Mvc.ModelBinding;
 
@@ -35,6 +36,7 @@ public BindingInfo(BindingInfo other)
         PropertyFilterProvider = other.PropertyFilterProvider;
         RequestPredicate = other.RequestPredicate;
         EmptyBodyBehavior = other.EmptyBodyBehavior;
+        ServiceKey = other.ServiceKey;
     }
 
     /// <summary>
@@ -89,6 +91,11 @@ public Type? BinderType
     /// </summary>
     public EmptyBodyBehavior EmptyBodyBehavior { get; set; }
 
+    /// <summary>
+    /// Get or sets the value used as the key when looking for a keyed service
+    /// </summary>
+    public object? ServiceKey { get; set; }
+
     /// <summary>
     /// Constructs a new instance of <see cref="BindingInfo"/> from the given <paramref name="attributes"/>.
     /// <para>
@@ -169,6 +176,19 @@ public Type? BinderType
             break;
         }
 
+        // Keyed services
+        if (attributes.OfType<FromKeyedServicesAttribute>().FirstOrDefault() is { } fromKeyedServicesAttribute)
+        {
+            if (bindingInfo.BindingSource != null)
+            {
+                throw new NotSupportedException(
+                    $"The {nameof(FromKeyedServicesAttribute)} is not supported on parameters that are also annotated with {nameof(IBindingSourceMetadata)}.");
+            }
+            isBindingInfoPresent = true;
+            bindingInfo.BindingSource = BindingSource.Services;
+            bindingInfo.ServiceKey = fromKeyedServicesAttribute.Key;
+        }
+
         return isBindingInfoPresent ? bindingInfo : null;
     }
 

src/Mvc/Mvc.Abstractions/src/PublicAPI.Unshipped.txt

@@ -1 +1,3 @@
 #nullable enable
+Microsoft.AspNetCore.Mvc.ModelBinding.BindingInfo.ServiceKey.get -> object?
+Microsoft.AspNetCore.Mvc.ModelBinding.BindingInfo.ServiceKey.set -> void

src/Mvc/Mvc.Abstractions/test/ModelBinding/BindingInfoTest.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.AspNetCore.Mvc.ModelBinding.Binders;
+using Microsoft.Extensions.DependencyInjection;
 using Moq;
 
 namespace Microsoft.AspNetCore.Mvc.ModelBinding;
@@ -286,4 +287,43 @@ public void GetBindingInfo_WithAttributesAndModelMetadata_PreserveEmptyBodyDefau
         Assert.NotNull(bindingInfo);
         Assert.Equal(EmptyBodyBehavior.Default, bindingInfo.EmptyBodyBehavior);
     }
+
+    [Fact]
+    public void GetBindingInfo_WithFromKeyedServicesAttribute()
+    {
+        // Arrange
+        var key = new object();
+        var attributes = new object[]
+        {
+                new FromKeyedServicesAttribute(key),
+        };
+        var modelType = typeof(Guid);
+        var provider = new TestModelMetadataProvider();
+        var modelMetadata = provider.GetMetadataForType(modelType);
+
+        // Act
+        var bindingInfo = BindingInfo.GetBindingInfo(attributes, modelMetadata);
+
+        // Assert
+        Assert.NotNull(bindingInfo);
+        Assert.Same(BindingSource.Services, bindingInfo.BindingSource);
+        Assert.Same(key, bindingInfo.ServiceKey);
+    }
+
+    [Fact]
+    public void GetBindingInfo_ThrowsWhenWithFromKeyedServicesAttributeAndIFromServiceMetadata()
+    {
+        // Arrange
+        var attributes = new object[]
+        {
+                new FromKeyedServicesAttribute(new object()),
+                new FromServicesAttribute()
+        };
+        var modelType = typeof(Guid);
+        var provider = new TestModelMetadataProvider();
+        var modelMetadata = provider.GetMetadataForType(modelType);
+
+        // Act and Assert
+        Assert.Throws<NotSupportedException>(() => BindingInfo.GetBindingInfo(attributes, modelMetadata));
+    }
 }

src/Mvc/Mvc.Core/src/ModelBinding/Binders/KeyedServicesModelBinder.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.AspNetCore.Mvc.ModelBinding.Binders;
+
+internal class KeyedServicesModelBinder : IModelBinder
+{
+    private readonly object _key;
+    private readonly bool _isOptional;
+
+    public KeyedServicesModelBinder(object key, bool isOptional)
+    {
+        _key = key ?? throw new ArgumentNullException(nameof(key));
+        _isOptional = isOptional;
+    }
+
+    public Task BindModelAsync(ModelBindingContext bindingContext)
+    {
+        var keyedServices = bindingContext.HttpContext.RequestServices as IKeyedServiceProvider;
+        if (keyedServices == null)
+        {
+            bindingContext.Result = ModelBindingResult.Failed();
+            return Task.CompletedTask;
+        }
+
+        var model = _isOptional ?
+            keyedServices.GetKeyedService(bindingContext.ModelType, _key) :
+            keyedServices.GetRequiredKeyedService(bindingContext.ModelType, _key);
+
+        if (model != null)
+        {
+            bindingContext.ValidationState.Add(model, new ValidationStateEntry() { SuppressValidation = true });
+        }
+
+        bindingContext.Result = ModelBindingResult.Success(model);
+        return Task.CompletedTask;
+    }
+}

src/Mvc/Mvc.Core/src/ModelBinding/Binders/ServicesModelBinderProvider.cs

@@ -25,12 +25,17 @@ public class ServicesModelBinderProvider : IModelBinderProvider
         {
             // IsRequired will be false for a Reference Type
             // without a default value in a oblivious nullability context
-            // however, for services we shoud treat them as required
+            // however, for services we should treat them as required
             var isRequired = context.Metadata.IsRequired ||
                     (context.Metadata.Identity.ParameterInfo?.HasDefaultValue != true &&
                         !context.Metadata.ModelType.IsValueType &&
                         context.Metadata.NullabilityState == NullabilityState.Unknown);
 
+            if (context.BindingInfo.ServiceKey != null)
+            {
+                return new KeyedServicesModelBinder(context.BindingInfo.ServiceKey, !isRequired);
+            }
+
             return isRequired ? _servicesBinder : _optionalServicesBinder;
         }
 

src/Mvc/test/Mvc.FunctionalTests/KeyedServicesTests.cs

@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Net.Http;
+
+namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
+
+public class KeyedServicesTests : IClassFixture<MvcTestFixture<BasicWebSite.StartupWithoutEndpointRouting>>
+{
+    public KeyedServicesTests(MvcTestFixture<BasicWebSite.StartupWithoutEndpointRouting> fixture)
+    {
+        Client = fixture.CreateDefaultClient();
+    }
+
+    public HttpClient Client { get; }
+
+    [Fact]
+    public async Task ExplicitSingleFromKeyedServiceAttribute()
+    {
+        // Arrange
+        var okRequest = new HttpRequestMessage(HttpMethod.Get, "/services/GetOk");
+        var notokRequest = new HttpRequestMessage(HttpMethod.Get, "/services/GetNotOk");
+
+        // Act
+        var okResponse = await Client.SendAsync(okRequest);
+        var notokResponse = await Client.SendAsync(notokRequest);
+
+        // Assert
+        Assert.True(okResponse.IsSuccessStatusCode);
+        Assert.True(notokResponse.IsSuccessStatusCode);
+        Assert.Equal("OK", await okResponse.Content.ReadAsStringAsync());
+        Assert.Equal("NOT OK", await notokResponse.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task ExplicitMultipleFromKeyedServiceAttribute()
+    {
+        // Arrange
+        var request = new HttpRequestMessage(HttpMethod.Get, "/services/GetBoth");
+
+        // Act
+        var response = await Client.SendAsync(request);
+
+        // Assert
+        Assert.True(response.IsSuccessStatusCode);
+        Assert.Equal("OK,NOT OK", await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task ExplicitSingleFromKeyedServiceAttributeWithNullKey()
+    {
+        // Arrange
+        var request = new HttpRequestMessage(HttpMethod.Get, "/services/GetKeyNull");
+
+        // Act
+        var response = await Client.SendAsync(request);
+
+        // Assert
+        Assert.True(response.IsSuccessStatusCode);
+        Assert.Equal("DEFAULT", await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task ExplicitSingleFromKeyedServiceAttributeOptionalNotRegistered()
+    {
+        // Arrange
+        var request = new HttpRequestMessage(HttpMethod.Get, "/services/GetOptionalNotRegistered");
+
+        // Act
+        var response = await Client.SendAsync(request);
+
+        // Assert
+        Assert.True(response.IsSuccessStatusCode);
+        Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());
+    }
+
+    [Fact]
+    public async Task ExplicitSingleFromKeyedServiceAttributeRequiredNotRegistered()
+    {
+        // Arrange
+        var request = new HttpRequestMessage(HttpMethod.Get, "/services/GetRequiredNotRegistered");
+
+        // Act
+        var response = await Client.SendAsync(request);
+
+        // Assert
+        Assert.False(response.IsSuccessStatusCode);
+    }
+}

src/Mvc/test/WebSites/BasicWebSite/Controllers/CustomServiceApiController.cs

@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Mvc;
+
+namespace BasicWebSite;
+
+[ApiController]
+[Route("/services")]
+public class CustomServicesApiController : Controller
+{
+    [HttpGet("GetOk")]
+    public ActionResult<string> GetOk([FromKeyedServices("ok_service")] ICustomService service)
+    {
+        return service.Process();
+    }
+
+    [HttpGet("GetNotOk")]
+    public ActionResult<string> GetNotOk([FromKeyedServices("not_ok_service")] ICustomService service)
+    {
+        return service.Process();
+    }
+
+    [HttpGet("GetBoth")]
+    public ActionResult<string> GetBoth(
+        [FromKeyedServices("ok_service")] ICustomService s1,
+        [FromKeyedServices("not_ok_service")] ICustomService s2)
+    {
+        return $"{s1.Process()},{s2.Process()}";
+    }
+
+    [HttpGet("GetKeyNull")]
+    public ActionResult<string> GetKeyNull([FromKeyedServices(null)] ICustomService service)
+    {
+        return service.Process();
+    }
+
+# nullable enable
+
+    [HttpGet("GetOptionalNotRegistered")]
+    public ActionResult<string> GetOptionalNotRegistered([FromKeyedServices("no_existing_key")] ICustomService? service)
+    {
+        if (service != null)
+        {
+            throw new Exception("Service should not have been resolved");
+        }
+        return string.Empty;
+    }
+
+    [HttpGet("GetRequiredNotRegistered")]
+    public ActionResult<string> GetRequiredNotRegistered([FromKeyedServices("no_existing_key")] ICustomService service)
+    {
+        return service.Process();
+    }
+}

src/Mvc/test/WebSites/BasicWebSite/CustomService.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using BasicWebSite.Models;
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BasicWebSite;
+
+public interface ICustomService
+{
+    string Process();
+}
+
+public class OkCustomService : ICustomService
+{
+    public string Process() => "OK";
+    public override string ToString() => Process();
+}
+
+public class BadCustomService : ICustomService
+{
+    public string Process() => "NOT OK";
+    public override string ToString() => Process();
+}
+
+public class DefaultCustomService : ICustomService
+{
+    public string Process() => "DEFAULT";
+    public override string ToString() => Process();
+    public static DefaultCustomService Instance => new DefaultCustomService();
+}

src/Mvc/test/WebSites/BasicWebSite/StartupWithoutEndpointRouting.cs

@@ -43,6 +43,9 @@ public void ConfigureServices(IServiceCollection services)
         services.AddSingleton<IActionDescriptorProvider, ActionDescriptorCreationCounter>();
         services.AddHttpContextAccessor();
         services.AddSingleton<ContactsRepository>();
+        services.AddKeyedSingleton<ICustomService, OkCustomService>("ok_service");
+        services.AddKeyedSingleton<ICustomService, BadCustomService>("not_ok_service");
+        services.AddSingleton<ICustomService, DefaultCustomService>();
         services.AddScoped<RequestIdService>();
         services.AddTransient<ServiceActionFilter>();
         services.AddScoped<TestResponseGenerator>();