Throw if resolving keyed service from non-keyed container (#53051)

* Throw if resolving keyed service from non-keyed container

* Update message and add tests

* Fix reference

* Check for RDF exception at construction time

Author: captainsafia

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointParameterEmitter.cs

@@ -335,6 +335,11 @@ internal static void EmitKeyedServiceParameterPreparation(this EndpointParameter
     {
         codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment());
 
+        codeWriter.WriteLine("if (httpContext.RequestServices.GetService<IServiceProviderIsService>() is not IServiceProviderIsKeyedService)");
+        codeWriter.StartBlock();
+        codeWriter.WriteLine(@"throw new InvalidOperationException($""Unable to resolve {nameof(FromKeyedServicesAttribute)}. This service provider doesn't support keyed services."");");
+        codeWriter.EndBlock();
+
         var assigningCode = endpointParameter.IsOptional ?
             $"httpContext.RequestServices.GetKeyedService<{endpointParameter.Type}>({endpointParameter.KeyedServiceKey});" :
             $"httpContext.RequestServices.GetRequiredKeyedService<{endpointParameter.Type}>({endpointParameter.KeyedServiceKey})";

src/Http/Http.Extensions/src/RequestDelegateFactory.cs

@@ -788,6 +788,10 @@ private static Expression CreateArgument(ParameterInfo parameter, RequestDelegat
         }
         else if (parameterCustomAttributes.OfType<FromKeyedServicesAttribute>().FirstOrDefault() is { } keyedServicesAttribute)
         {
+            if (factoryContext.ServiceProviderIsService is not IServiceProviderIsKeyedService)
+            {
+                throw new InvalidOperationException($"Unable to resolve {nameof(FromKeyedServicesAttribute)}. This service provider doesn't support keyed services.");
+            }
             var key = keyedServicesAttribute.Key;
             return BindParameterFromKeyedService(parameter, key, factoryContext);
         }

src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.KeyServices.cs

@@ -3,6 +3,8 @@
 using Microsoft.AspNetCore.Http.Metadata;
 using Microsoft.AspNetCore.Http.RequestDelegateGenerator;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+
 namespace Microsoft.AspNetCore.Http.Generators.Tests;
 
 public partial class RequestDelegateCreationTests : RequestDelegateCreationTestBase
@@ -197,4 +199,44 @@ public async Task SupportsMultipleKeyedAndNonKeyedServices()
         Assert.IsType<TestService>(httpContext.Items["arg2"]);
         Assert.Same(myOriginalService2, httpContext.Items["arg3"]);
     }
+
+    [Fact]
+    public async Task ThrowsIfDiContainerDoesNotSupportKeyedServices()
+    {
+        var source = """
+ app.MapGet("/", (HttpContext context, [FromKeyedServices("service1")] TestService arg1) =>
+ {
+     context.Items["arg1"] = arg1;
+ });
+ """;
+        var (_, compilation) = await RunGeneratorAsync(source);
+        var serviceProvider = new MockServiceProvider();
+        if (!IsGeneratorEnabled)
+        {
+            var runtimeException = Assert.Throws<InvalidOperationException>(() => GetEndpointFromCompilation(compilation, serviceProvider: serviceProvider));
+            Assert.Equal("Unable to resolve FromKeyedServicesAttribute. This service provider doesn't support keyed services.", runtimeException.Message);
+            return;
+        }
+        var endpoint = GetEndpointFromCompilation(compilation, serviceProvider: serviceProvider);
+
+        var httpContext = CreateHttpContext(serviceProvider);
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await endpoint.RequestDelegate(httpContext));
+        Assert.Equal("Unable to resolve FromKeyedServicesAttribute. This service provider doesn't support keyed services.", exception.Message);
+    }
+
+    private class MockServiceProvider : IServiceProvider, ISupportRequiredService
+    {
+        public object GetService(Type serviceType)
+        {
+            if (serviceType == typeof(Microsoft.Extensions.Logging.ILoggerFactory))
+            {
+                return NullLoggerFactory.Instance;
+            }
+            return null;
+        }
+        public object GetRequiredService(Type serviceType)
+        {
+            return GetService(serviceType);
+        }
+    }
 }