Fix up disposable code and improve paths perf

Author: captainsafia

src/OpenApi/src/Services/OpenApiDocumentService.cs

@@ -70,25 +70,7 @@ private async Task ApplyTransformersAsync(OpenApiDocument document, Cancellation
         for (var i = 0; i < _options.DocumentTransformers.Count; i++)
         {
             var transformer = _options.DocumentTransformers[i];
-            try
-            {
-                await transformer.TransformAsync(document, documentTransformerContext, cancellationToken);
-            }
-            finally
-            {
-                if (transformer is IDisposable disposable)
-                {
-                    disposable.Dispose();
-                }
-                if (transformer is IAsyncDisposable asyncDisposable)
-                {
-                    await asyncDisposable.DisposeAsync();
-                }
-                if (transformer is TypeBasedOpenApiDocumentTransformer typedTransformer)
-                {
-                    await typedTransformer.DisposeAsync();
-                }
-            }
+            await transformer.TransformAsync(document, documentTransformerContext, cancellationToken);
         }
     }
 

src/OpenApi/src/Transformers/DelegateOpenApiDocumentTransformer.cs

@@ -9,6 +9,20 @@ namespace Microsoft.AspNetCore.OpenApi;
 
 internal sealed class DelegateOpenApiDocumentTransformer : IOpenApiDocumentTransformer
 {
+    // Since there's a finite set of operation types that can be included in a given
+    // OpenApiPaths, we can pre-allocate an array of these types and use a direct
+    // lookup on the OpenApiPaths dictionary to avoid allocating an enumerator
+    // over the KeyValuePairs in OpenApiPaths.
+    private static readonly OperationType[] _operationTypes = [
+        OperationType.Get,
+        OperationType.Post,
+        OperationType.Put,
+        OperationType.Delete,
+        OperationType.Options,
+        OperationType.Head,
+        OperationType.Patch,
+        OperationType.Trace
+    ];
     private readonly Func<OpenApiDocument, OpenApiDocumentTransformerContext, CancellationToken, Task>? _documentTransformer;
     private readonly Func<OpenApiOperation, OpenApiOperationTransformerContext, CancellationToken, Task>? _operationTransformer;
 
@@ -34,8 +48,14 @@ public async Task TransformAsync(OpenApiDocument document, OpenApiDocumentTransf
             var documentService = context.ApplicationServices.GetRequiredKeyedService<OpenApiDocumentService>(context.DocumentName);
             foreach (var pathItem in document.Paths.Values)
             {
-                foreach (var operation in pathItem.Operations.Values)
+                for (var i = 0; i < _operationTypes.Length; i++)
                 {
+                    var operationType = _operationTypes[i];
+                    if (!pathItem.Operations.TryGetValue(operationType, out var operation))
+                    {
+                        continue;
+                    }
+
                     if (operation.Extensions.TryGetValue(OpenApiConstants.DescriptionId, out var descriptionIdExtension) &&
                         descriptionIdExtension is OpenApiString { Value: var descriptionId } &&
                         documentService.TryGetCachedOperationTransformerContext(descriptionId, out var operationContext))

src/OpenApi/src/Transformers/TypeBasedOpenApiDocumentTransformer.cs

@@ -10,25 +10,25 @@ namespace Microsoft.AspNetCore.OpenApi;
 internal sealed class TypeBasedOpenApiDocumentTransformer(Type transformerType) : IOpenApiDocumentTransformer
 {
     private readonly ObjectFactory _transformerFactory = ActivatorUtilities.CreateFactory(transformerType, []);
-    private IOpenApiDocumentTransformer? _transformer;
 
-    public ValueTask DisposeAsync()
+    public async Task TransformAsync(OpenApiDocument document, OpenApiDocumentTransformerContext context, CancellationToken cancellationToken)
     {
-        if (_transformer is IAsyncDisposable asyncDisposable)
+        var transformer = _transformerFactory.Invoke(context.ApplicationServices, []) as IOpenApiDocumentTransformer;
+        Debug.Assert(transformer != null, $"The type {transformerType} does not implement {nameof(IOpenApiDocumentTransformer)}.");
+        try
         {
-            return asyncDisposable.DisposeAsync();
+            await transformer.TransformAsync(document, context, cancellationToken);
         }
-        if (_transformer is IDisposable disposable)
+        finally
         {
-            disposable.Dispose();
+            if (transformer is IAsyncDisposable asyncDisposable)
+            {
+                await asyncDisposable.DisposeAsync();
+            }
+            else if (transformer is IDisposable disposable)
+            {
+                disposable.Dispose();
+            }
         }
-        return ValueTask.CompletedTask;
-    }
-
-    public Task TransformAsync(OpenApiDocument document, OpenApiDocumentTransformerContext context, CancellationToken cancellationToken)
-    {
-        _transformer = _transformerFactory.Invoke(context.ApplicationServices, []) as IOpenApiDocumentTransformer;
-        Debug.Assert(_transformer != null, $"The type {transformerType} does not implement {nameof(IOpenApiDocumentTransformer)}.");
-        return _transformer.TransformAsync(document, context, cancellationToken);
     }
 }

src/OpenApi/test/Transformers/DocumentTransformerTests.cs

@@ -122,46 +122,6 @@ await VerifyOpenApiDocument(builder, options, document =>
         });
     }
 
-    [Fact]
-    public async Task DocumentTransformer_SupportsDisposableInstanceTransformer()
-    {
-        var builder = CreateBuilder();
-
-        builder.MapGet("/todo", () => { });
-        builder.MapGet("/user", () => { });
-
-        var options = new OpenApiOptions();
-        var transformer = new DisposableTransformer();
-        options.UseTransformer(transformer);
-
-        Assert.False(transformer.Disposed);
-        await VerifyOpenApiDocument(builder, options, document =>
-        {
-            Assert.Equal("Info Description", document.Info.Description);
-        });
-        Assert.True(transformer.Disposed);
-    }
-
-    [Fact]
-    public async Task DocumentTransformer_SupportsAsyncDisposableInstanceTransformer()
-    {
-        var builder = CreateBuilder();
-
-        builder.MapGet("/todo", () => { });
-        builder.MapGet("/user", () => { });
-
-        var options = new OpenApiOptions();
-        var transformer = new AsyncDisposableTransformer();
-        options.UseTransformer(transformer);
-
-        Assert.False(transformer.Disposed);
-        await VerifyOpenApiDocument(builder, options, document =>
-        {
-            Assert.Equal("Info Description", document.Info.Description);
-        });
-        Assert.True(transformer.Disposed);
-    }
-
     [Fact]
     public async Task DocumentTransformer_SupportsDisposableActivatedTransformer()
     {