Update OpenApi implementation to avoid reflection

Author: Youssef1313

examples/AspNetCore/WebApi/MinimalOpenApiExample/MinimalOpenApiExample.csproj

@@ -4,6 +4,9 @@
   <TargetFramework>net10.0</TargetFramework>
   <AssemblyTitle>Example API</AssemblyTitle>
   <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  <InterceptorsNamespaces>$(InterceptorsNamespaces);Microsoft.AspNetCore.OpenApi.Generated</InterceptorsNamespaces>
+  <OpenApiGenerateDocuments>false</OpenApiGenerateDocuments>
+  <OpenApiGenerateDocumentsOnBuild>false</OpenApiGenerateDocumentsOnBuild>
  </PropertyGroup>
 
  <ItemGroup>

src/AspNetCore/WebApi/src/Asp.Versioning.Http/DependencyInjection/ApiVersioningBuilder.cs

@@ -5,10 +5,184 @@
 namespace Microsoft.Extensions.DependencyInjection;
 
 using Asp.Versioning;
+using System.Collections;
+using System.Diagnostics;
 
 internal sealed class ApiVersioningBuilder : IApiVersioningBuilder
 {
-    public ApiVersioningBuilder( IServiceCollection services ) => Services = services;
+    public ApiVersioningBuilder( IServiceCollection services ) => Services = new MutableServiceCollection(services);
 
     public IServiceCollection Services { get; }
+
+    private sealed class MutableServiceCollection : IServiceCollection
+    {
+        private readonly List<ServiceDescriptor> descriptors = new List<ServiceDescriptor>();
+        private readonly IServiceCollection inner;
+
+        public MutableServiceCollection(IServiceCollection inner)
+            => this.inner = inner;
+
+        private bool IndexIsInOurList( int index, out int mappedIndex )
+        {
+            mappedIndex = index - inner.Count;
+            return mappedIndex >= 0 && mappedIndex < descriptors.Count;
+        }
+
+        public ServiceDescriptor this[int index]
+        {
+            get => IndexIsInOurList( index, out int mappedIndex ) ? descriptors[mappedIndex] : inner[index];
+            set
+            {
+                if ( IndexIsInOurList( index, out int mappedIndex ) )
+                {
+                    descriptors[mappedIndex] = value;
+                }
+                else
+                {
+                    inner[index] = value;
+                }
+            }
+        }
+
+        public int Count => inner.Count + descriptors.Count;
+
+        // while current instance isn't in theory read only.
+        // fake it to limit exposure.
+        // Mutating the services after build is done is extremely bad.
+        // It's mutated only by OpenAPI implementation so far which won't check for IsReadOnly.
+        public bool IsReadOnly => inner.IsReadOnly;
+
+        public void Add( ServiceDescriptor item )
+        {
+            if ( !inner.IsReadOnly )
+            {
+                inner.Add( item );
+            }
+            else
+            {
+                descriptors.Add( item );
+            }
+        }
+
+        public void Clear()
+        {
+            inner.Clear();
+            descriptors.Clear();
+        }
+
+        public bool Contains( ServiceDescriptor item )
+            => inner.Contains( item ) || descriptors.Contains( item );
+
+        public void CopyTo( ServiceDescriptor[] array, int arrayIndex )
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerator<ServiceDescriptor> GetEnumerator()
+            => new CombinedEnumerator( inner, descriptors );
+
+        public int IndexOf( ServiceDescriptor item )
+        {
+            var indexInInner = inner.IndexOf( item );
+            if ( indexInInner >= 0 )
+            {
+                return indexInInner;
+            }
+
+            var indexInCurrent = descriptors.IndexOf( item );
+            if ( indexInCurrent >= 0 )
+            {
+                return indexInCurrent + inner.Count;
+            }
+
+            return -1;
+        }
+
+        public void Insert( int index, ServiceDescriptor item )
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Remove( ServiceDescriptor item )
+            => inner.Remove( item ) || descriptors.Remove( item );
+
+        public void RemoveAt( int index )
+        {
+            if ( IndexIsInOurList( index, out var mappedIndex ) )
+            {
+                descriptors.RemoveAt( mappedIndex );
+            }
+            else
+            {
+                inner.RemoveAt( index );
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+
+    private sealed class CombinedEnumerator : IEnumerator<ServiceDescriptor>
+    {
+        private readonly IServiceCollection inner;
+        private readonly IList<ServiceDescriptor> descriptors;
+
+        private IEnumerator<ServiceDescriptor>? enumerator1;
+        private IEnumerator<ServiceDescriptor>? enumerator2;
+
+        public CombinedEnumerator(IServiceCollection inner, IList<ServiceDescriptor> descriptors)
+        {
+            this.inner = inner;
+            this.descriptors = descriptors;
+        }
+
+        public ServiceDescriptor Current => enumerator2 is not null ? enumerator2.Current : enumerator1!.Current;
+
+        object IEnumerator.Current => Current;
+
+        public void Dispose()
+        {
+            enumerator1?.Dispose();
+            enumerator2?.Dispose();
+        }
+
+        public bool MoveNext()
+        {
+            if ( enumerator1 is null && enumerator2 is null )
+            {
+                enumerator1 = inner.GetEnumerator();
+            }
+
+            if ( enumerator2 is not null )
+            {
+                return enumerator2.MoveNext();
+            }
+            else if ( enumerator1 is not null )
+            {
+                if ( enumerator1.MoveNext() )
+                {
+                    return true;
+                }
+                else
+                {
+                    enumerator2 = descriptors.GetEnumerator();
+                    return enumerator2.MoveNext();
+                }
+            }
+            else
+            {
+                throw new UnreachableException();
+            }
+        }
+
+        public void Reset()
+        {
+            enumerator1?.Dispose();
+            enumerator2?.Dispose();
+            enumerator1 = null;
+            enumerator2 = null;
+        }
+    }
 }

src/AspNetCore/WebApi/src/Asp.Versioning.OpenApi/Builder/IEndpointConventionBuilderExtensions.cs

@@ -6,7 +6,6 @@ namespace Microsoft.AspNetCore.Builder;
 
 using Asp.Versioning;
 using Asp.Versioning.ApiExplorer;
-using Asp.Versioning.OpenApi.Reflection;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
@@ -44,12 +43,12 @@ private static void ApplyApiVersioning( EndpointBuilder builder )
 
     private static Task InterceptRequestServices( HttpContext context, RequestDelegate action )
     {
-        if ( context.RequestServices is not KeyedServiceContainer requestServices )
+        if ( context.RequestServices is not AggregateKeyedServiceProvider serviceProvider )
         {
-            requestServices = context.RequestServices.GetRequiredService<KeyedServiceContainer>();
+            serviceProvider = context.RequestServices.GetRequiredService<AggregateKeyedServiceProvider>();
         }
 
-        context.RequestServices = requestServices;
+        context.RequestServices = serviceProvider;
         return action( context );
     }
 }

src/AspNetCore/WebApi/src/Asp.Versioning.OpenApi/Configuration/ConfigureOpenApiOptions.cs

@@ -5,10 +5,11 @@
 namespace Asp.Versioning.OpenApi.Configuration;
 
 using Asp.Versioning.ApiExplorer;
-using Asp.Versioning.OpenApi.Reflection;
 using Asp.Versioning.OpenApi.Transformers;
 using Microsoft.AspNetCore.OpenApi;
 using Microsoft.Extensions.Options;
+using System.Net;
+using System.Runtime.CompilerServices;
 
 internal sealed class ConfigureOpenApiOptions(
     XmlCommentsTransformer xmlComments,
@@ -48,7 +49,7 @@ private static void Configure( VersionedOpenApiOptions versionedOptions, XmlComm
         var options = versionedOptions.Document;
         var apiExplorer = new ApiExplorerTransformer( versionedOptions );
 
-        options.SetDocumentName( versionedOptions.Description.GroupName );
+        SetDocumentName( options, versionedOptions.Description.GroupName );
         options.AddDocumentTransformer( apiExplorer );
         options.AddSchemaTransformer( apiExplorer );
         options.AddOperationTransformer( apiExplorer );
@@ -59,4 +60,7 @@ private static void Configure( VersionedOpenApiOptions versionedOptions, XmlComm
             options.AddOperationTransformer( xmlComments );
         }
     }
+
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_DocumentName")]
+    private static extern void SetDocumentName( OpenApiOptions handler, string value );
 }

src/AspNetCore/WebApi/src/Asp.Versioning.OpenApi/DependencyInjection/AggregateKeyedServiceProvider.cs

@@ -0,0 +1,60 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+
+#pragma warning disable IDE0130
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+internal sealed class AggregateKeyedServiceProvider( IServiceProvider parent ) : IKeyedServiceProvider
+{
+    private readonly IServiceProvider parent = parent;
+    private readonly List<IServiceProvider> providers = [];
+
+    public object? GetKeyedService( Type serviceType, object? serviceKey )
+    {
+        if ( providers.Count == 0 )
+        {
+            return parent.GetKeyedService( serviceType, serviceKey );
+        }
+
+        foreach ( var provider in providers )
+        {
+            if ( provider.GetKeyedService( serviceType, serviceKey ) is { } service )
+            {
+                return service;
+            }
+        }
+
+        return null;
+    }
+
+    public object GetRequiredKeyedService( Type serviceType, object? serviceKey )
+    {
+        if ( providers.Count == 0 )
+        {
+            return parent.GetRequiredKeyedService( serviceType, serviceKey );
+        }
+
+        for ( int i = 0; i < providers.Count - 1; i++ )
+        {
+            if ( providers[i].GetKeyedService( serviceType, serviceKey ) is { } service )
+            {
+                return service;
+            }
+        }
+
+        return providers[providers.Count - 1].GetRequiredKeyedService( serviceType, serviceKey );
+    }
+
+    public object? GetService( Type serviceType )
+        => parent.GetService( serviceType );
+
+    public void Add( IServiceCollection serviceCollection, IServiceCollection parentServiceCollection )
+    {
+        foreach ( var descriptor in parentServiceCollection )
+        {
+            serviceCollection.Add( descriptor );
+        }
+
+        providers.Add( serviceCollection.BuildServiceProvider() );
+    }
+}