From 60e3d8ed06118b0b7141531e15ea61cf7c045463 Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Mon, 5 May 2025 10:55:33 +0800
Subject: [PATCH 01/16] Using GZip to compress swagger-ui-dist files in
 embedded resource to reduce the output dll size

---
 .gitignore                                    |   3 +-
 Directory.Packages.props                      |   3 +-
 .../GZipCompressedEmbeddedFileProvider.cs     | 143 ++++++++++++++++++
 .../SwaggerUIMiddleware.cs                    |   3 +-
 .../Swashbuckle.AspNetCore.SwaggerUI.csproj   |  10 +-
 .../SwaggerUIIntegrationTests.cs              |  78 ++++++++++
 6 files changed, 235 insertions(+), 5 deletions(-)
 create mode 100644 src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs

diff --git a/.gitignore b/.gitignore
index 0857e5a38e..9ef250aa55 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
-[Oo]bj/
+[Oo]bj/
 [Bb]in/
+[Tt]est[Rr]esult*/
 .vs/
 .idea*
 BenchmarkDotNet.Artifacts*/
diff --git a/Directory.Packages.props b/Directory.Packages.props
index ad33649e3b..3a2f7a1026 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -1,4 +1,4 @@
-<Project>
+<Project>
   <ItemGroup>
     <PackageVersion Include="Autofac.Extensions.DependencyInjection" Version="10.0.0" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
@@ -29,6 +29,7 @@
     <PackageVersion Include="NSubstitute" Version="5.3.0" />
     <PackageVersion Include="NSwag.MSBuild" Version="14.4.0" />
     <PackageVersion Include="ReportGenerator" Version="5.4.4" />
+    <PackageVersion Include="ResourceCompressor" Version="1.0.1" />
     <PackageVersion Include="System.Text.Json" Version="4.6.0" />
     <PackageVersion Include="Verify.XunitV3" Version="29.3.0" />
     <PackageVersion Include="xunit" Version="2.9.3" />
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
new file mode 100644
index 0000000000..e51f851fd4
--- /dev/null
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
@@ -0,0 +1,143 @@
+using System.Buffers;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.IO.Compression;
+using System.Reflection;
+
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Primitives;
+
+namespace Swashbuckle.AspNetCore.SwaggerUI;
+
+/// <summary>
+/// a <see cref="EmbeddedFileProvider"/> wrapper to provider gzip decompressed resource file info
+/// </summary>
+/// <param name="assembly"></param>
+/// <param name="baseNamespace"></param>
+internal sealed class GZipCompressedEmbeddedFileProvider(Assembly assembly, string baseNamespace) : IFileProvider
+{
+    private readonly string _baseNamespace = string.IsNullOrEmpty(baseNamespace) ? string.Empty : baseNamespace + ".";
+
+    private readonly EmbeddedFileProvider _embeddedFileProvider = new(assembly, baseNamespace);
+
+    private readonly ConcurrentDictionary<string, long> _subpathLengthCache = new(StringComparer.Ordinal);
+
+    /// <inheritdoc/>
+    public IDirectoryContents GetDirectoryContents(string subpath)
+    {
+        //logic same as EmbeddedFileProvider
+        return subpath?.Length == 0 || string.Equals(subpath, "/", StringComparison.Ordinal)
+               ? new DecompresDirectoryContents(EnumerateItems().ToList())
+               : new DecompresDirectoryContents([]);
+    }
+
+    /// <inheritdoc/>
+    public IFileInfo GetFileInfo(string subpath) => new GZipDecompresFileInfoWrapper(_embeddedFileProvider.GetFileInfo(subpath), subpath, GetSubpathDecompressedLength);
+
+    /// <inheritdoc/>
+    public IChangeToken Watch(string filter) => _embeddedFileProvider.Watch(filter);
+
+    private static string NormalizeSubPath(string subpath) => string.Join(".", subpath.Split(['/', '\\'], StringSplitOptions.RemoveEmptyEntries).Where(m => !string.IsNullOrWhiteSpace(m)));
+
+    /// <summary>
+    /// Get the <paramref name="stream"/>'s length by decompress and read it
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <returns></returns>
+    private static long ReadStreamDecompressedLength(Stream stream)
+    {
+        const int BufferSize = 4096;
+
+        long length = 0;
+        var buffer = ArrayPool<byte>.Shared.Rent(BufferSize);
+
+        try
+        {
+            using var gzipStream = new GZipStream(stream, CompressionMode.Decompress, true);
+            var readLength = 0;
+            do
+            {
+                readLength = gzipStream.Read(buffer, 0, BufferSize);
+                length += readLength;
+            } while (readLength != 0);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+        return length;
+    }
+
+    private IEnumerable<IFileInfo> EnumerateItems()
+    {
+        return assembly.GetManifestResourceNames()
+                       .Where(name => name.StartsWith(_baseNamespace))
+                       .Select(name => name.Substring(_baseNamespace.Length))
+                       .Select(subpath => this.GetFileInfo(subpath))
+                       .Where(static fileInfo => fileInfo.Exists);
+    }
+
+    /// <summary>
+    /// Get <paramref name="subpath"/>'s decompressed length and cache it
+    /// </summary>
+    /// <param name="subpath"></param>
+    /// <returns></returns>
+    private long GetSubpathDecompressedLength(string subpath)
+    {
+        if (_subpathLengthCache.TryGetValue(subpath, out var length))
+        {
+            return length;
+        }
+
+        var resourceName = $"{_baseNamespace}{NormalizeSubPath(subpath)}";
+
+        using var stream = assembly.GetManifestResourceStream(resourceName);
+        if (stream == null)
+        {
+            return -1;
+        }
+
+        return _subpathLengthCache.GetOrAdd(subpath, _ => ReadStreamDecompressedLength(stream));
+    }
+
+    private sealed class DecompresDirectoryContents(List<IFileInfo> fileInfos) : IDirectoryContents
+    {
+        /// <inheritdoc/>
+        public bool Exists => fileInfos.Count > 0;
+
+        /// <inheritdoc/>
+        public IEnumerator<IFileInfo> GetEnumerator() => fileInfos.GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+
+    private sealed class GZipDecompresFileInfoWrapper(IFileInfo fileInfo, string subpath, Func<string, long> getSubpathLengthFunc) : IFileInfo
+    {
+        /// <inheritdoc/>
+        public bool Exists => fileInfo.Exists;
+
+        /// <inheritdoc/>
+        public bool IsDirectory => fileInfo.IsDirectory;
+
+        /// <inheritdoc/>
+        public DateTimeOffset LastModified => fileInfo.LastModified;
+
+        /// <inheritdoc/>
+        public long Length => fileInfo.Exists ? getSubpathLengthFunc(subpath) : -1;
+
+        /// <inheritdoc/>
+        public string Name => fileInfo.Name;
+
+        /// <inheritdoc/>
+        public string PhysicalPath => fileInfo.PhysicalPath;
+
+        /// <inheritdoc/>
+        public Stream CreateReadStream()
+        {
+            return fileInfo.CreateReadStream() is { } stream
+                   ? new GZipStream(stream, CompressionMode.Decompress)
+                   : throw new FileNotFoundException(message: null, fileName: fileInfo.Name);
+        }
+    }
+}
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
index 77f454671a..e94931461f 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
@@ -4,7 +4,6 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.StaticFiles;
-using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System.Reflection;
@@ -110,7 +109,7 @@ private static StaticFileMiddleware CreateStaticFileMiddleware(
         var staticFileOptions = new StaticFileOptions
         {
             RequestPath = string.IsNullOrEmpty(options.RoutePrefix) ? string.Empty : $"/{options.RoutePrefix}",
-            FileProvider = new EmbeddedFileProvider(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace),
+            FileProvider = new GZipCompressedEmbeddedFileProvider(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace),
             OnPrepareResponse = (context) => SetCacheHeaders(context.Context.Response, options),
         };
 
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
index 00075542f3..39dfb18c47 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
@@ -16,7 +16,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <EmbeddedResource Include="node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" />
+    <InternalsVisibleTo Include="Swashbuckle.AspNetCore.IntegrationTests" Key="00240000048000009400000006020000002400005253413100040000010001000b80d002f0437a94c4f6d77dfc29ce54df1040f66374cb7122ec5ddab3907a6dfe609a07ffd49b9aa6731fe3f8de4da7979ddea73e949c86effc4bec3f469cc36e788cf58c42c4be755efd1afd996ccab9f0db3455b834219f6614d00fe0410cc307c4eced320fd65fcc501f135dc537d7d09dcc1d2a572d24f8459a86469ec5" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <CompressedEmbeddedResource Include="node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" GeneratedFileSuffix="None" />
     <None Remove="index.html;index.js" />
     <EmbeddedResource Include="index.html;index.js" />
   </ItemGroup>
@@ -34,6 +38,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
+    <PackageReference Include="ResourceCompressor">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <AdditionalFiles Include="PublicAPI\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\PublicAPI.Unshipped.txt" />
   </ItemGroup>
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 410bf63822..cbc89d5014 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -1,4 +1,6 @@
 using System.Net;
+using Microsoft.Extensions.FileProviders;
+using Swashbuckle.AspNetCore.SwaggerUI;
 
 namespace Swashbuckle.AspNetCore.IntegrationTests;
 
@@ -23,6 +25,82 @@ public async Task RoutePrefix_RedirectsToPathRelativeIndexUrl(
         Assert.Equal(expectedRedirectPath, response.Headers.Location.ToString());
     }
 
+    [Theory]
+    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules")]
+    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules.swagger_ui_dist")]
+    public void ResourceRead_CompressedEmbeddedFileProvider(string baseNamespace)
+    {
+        //confirm that GZipCompressedEmbeddedFileProvider is the same as EmbeddedFileProvider
+        var provider = new EmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
+        var compressedProvider = new GZipCompressedEmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
+        var checkSubpaths = new string[]
+        {
+            "/",
+            null,
+            string.Empty,
+            " ",
+            "\t",
+            "\n",
+            "/swagger_ui_dist",
+            "swagger_ui_dist",
+            "/nodir",
+            "nodir"
+        };
+
+        foreach (var subpath in checkSubpaths)
+        {
+            AssertResources(provider, compressedProvider, subpath);
+        }
+
+        var nonExistentFile = Guid.NewGuid().ToString();
+        AssertFileInfo(provider.GetFileInfo(nonExistentFile), compressedProvider.GetFileInfo(nonExistentFile));
+
+        static void AssertResources(IFileProvider expectedProvider, IFileProvider actualProvider, string subpath)
+        {
+            var expectedContents = expectedProvider.GetDirectoryContents(subpath);
+            var actualContents = actualProvider.GetDirectoryContents(subpath);
+
+            Assert.Equal(expectedContents.Exists, actualContents.Exists);
+            Assert.Equal(expectedContents.Count(), actualContents.Count());
+            var actualResourceMap = actualContents.ToDictionary(m => m.Name);
+
+            foreach (var expectedFileInfo in expectedContents)
+            {
+                Assert.True(actualResourceMap.TryGetValue(expectedFileInfo.Name, out var actualFileInfo));
+                Assert.NotNull(actualFileInfo);
+                Assert.True(actualFileInfo.Exists);
+                AssertFileInfo(expectedFileInfo, actualFileInfo);
+                AssertFileInfo(expectedProvider.GetFileInfo(expectedFileInfo.Name), actualProvider.GetFileInfo(expectedFileInfo.Name));
+            }
+        }
+
+        static void AssertFileInfo(IFileInfo expectedFileInfo, IFileInfo actualFileInfo)
+        {
+            Assert.Equal(expectedFileInfo.Exists, actualFileInfo.Exists);
+            Assert.Equal(expectedFileInfo.IsDirectory, actualFileInfo.IsDirectory);
+            Assert.Equal(expectedFileInfo.LastModified, actualFileInfo.LastModified);
+            Assert.Equal(expectedFileInfo.PhysicalPath, actualFileInfo.PhysicalPath);
+
+            if (expectedFileInfo.Exists && !expectedFileInfo.IsDirectory)
+            {
+                Assert.True(actualFileInfo.Length > 0);
+
+                using var stream = actualFileInfo.CreateReadStream();
+                Assert.NotNull(stream);
+                var buffer = new byte[256];
+                var readLength = stream.Read(buffer, 0, buffer.Length);
+                Assert.True(readLength > 0);
+                //we can check for correctness here
+            }
+            else
+            {
+                Assert.Equal(expectedFileInfo.Length, actualFileInfo.Length);
+                Assert.ThrowsAny<FileNotFoundException>(() => expectedFileInfo.CreateReadStream());
+                Assert.ThrowsAny<FileNotFoundException>(() => actualFileInfo.CreateReadStream());
+            }
+        }
+    }
+
     [Theory]
     [InlineData(typeof(Basic.Startup), "/index.html", "/swagger-ui.js", "/index.css", "/swagger-ui.css")]
     [InlineData(typeof(CustomUIConfig.Startup), "/swagger/index.html", "/swagger/swagger-ui.js", "swagger/index.css", "/swagger/swagger-ui.css")]

From c73a5a1a1a2bb01fc19bd3eff86fff7560753248 Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Mon, 5 May 2025 23:20:00 +0800
Subject: [PATCH 02/16] Using GZip to compress redoc/bundles files. Add
 UIIntegrationTests for swagger and redoc assets check by http request. Add
 project Swashbuckle.AspNetCore.SwaggerUI.Test for
 GZipCompressedEmbeddedFileProvider unit test.

---
 Swashbuckle.AspNetCore.sln                    |   7 ++
 .../ReDocMiddleware.cs                        |   2 +-
 .../Swashbuckle.AspNetCore.ReDoc.csproj       |  10 +-
 .../GZipCompressedEmbeddedFileProvider.cs     |   4 +-
 .../SwaggerUIMiddleware.cs                    |   1 +
 .../Swashbuckle.AspNetCore.SwaggerUI.csproj   |   4 -
 .../ReDocIntegrationTests.cs                  |  19 ++++
 .../SwaggerUIIntegrationTests.cs              | 102 ++++--------------
 ...hbuckle.AspNetCore.IntegrationTests.csproj |   9 ++
 ...GZipCompressedEmbeddedFileProviderTests.cs |  92 ++++++++++++++++
 ...ashbuckle.AspNetCore.SwaggerUI.Test.csproj |  28 +++++
 11 files changed, 190 insertions(+), 88 deletions(-)
 create mode 100644 test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs
 create mode 100644 test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj

diff --git a/Swashbuckle.AspNetCore.sln b/Swashbuckle.AspNetCore.sln
index 459bbf319f..f051e4b0fd 100644
--- a/Swashbuckle.AspNetCore.sln
+++ b/Swashbuckle.AspNetCore.sln
@@ -126,6 +126,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "perf", "perf", "{0C7326F1-F
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Swashbuckle.AspNetCore.Benchmarks", "perf\Swashbuckle.AspNetCore.Benchmarks\Swashbuckle.AspNetCore.Benchmarks.csproj", "{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Swashbuckle.AspNetCore.SwaggerUI.Test", "test\Swashbuckle.AspNetCore.SwaggerUI.Test\Swashbuckle.AspNetCore.SwaggerUI.Test.csproj", "{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -284,6 +286,10 @@ Global
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -330,6 +336,7 @@ Global
 		{D06A88E8-6F42-4F40-943A-E266C0AE6EC9} = {DB3F57FC-1472-4F03-B551-43394DA3C5EB}
 		{F88B6070-BE3C-45F9-978C-2ECBA9518C24} = {DB3F57FC-1472-4F03-B551-43394DA3C5EB}
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13} = {0C7326F1-F731-4CF9-8A98-80F39541D28F}
+		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A} = {0ADCB223-F375-45AB-8BC4-834EC9C69554}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {36FC6A67-247D-4149-8EDD-79FFD1A75F51}
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
index 012a8ad0a3..4f6ecaba90 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
@@ -103,7 +103,7 @@ private static StaticFileMiddleware CreateStaticFileMiddleware(
         var staticFileOptions = new StaticFileOptions
         {
             RequestPath = string.IsNullOrEmpty(options.RoutePrefix) ? string.Empty : $"/{options.RoutePrefix}",
-            FileProvider = new EmbeddedFileProvider(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace),
+            FileProvider = new GZipCompressedEmbeddedFileProvider(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace),
             OnPrepareResponse = (context) => SetCacheHeaders(context.Context.Response, options),
         };
 
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
index 953668a98b..6a28d7409c 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
+++ b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
@@ -24,7 +24,7 @@
     <EmbeddedResource Include="index.css" />
     <EmbeddedResource Include="index.html" />
     <EmbeddedResource Include="index.js" />
-    <EmbeddedResource Include="node_modules/redoc/bundles/redoc.standalone.js" />
+    <CompressedEmbeddedResource Include="node_modules/redoc/bundles/redoc.standalone.js" GeneratedFileSuffix="None" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
@@ -40,6 +40,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
+    <PackageReference Include="ResourceCompressor">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <AdditionalFiles Include="PublicAPI\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\PublicAPI.Unshipped.txt" />
   </ItemGroup>
@@ -50,6 +54,10 @@
     <AdditionalFiles Include="PublicAPI\$(_TargetFrameworkIdentifier)\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\$(_TargetFrameworkIdentifier)\PublicAPI.Unshipped.txt" />
   </ItemGroup>
+  
+  <ItemGroup>
+    <Compile Include="..\Swashbuckle.AspNetCore.SwaggerUI\GZipCompressedEmbeddedFileProvider.cs" Link="GZipCompressedEmbeddedFileProvider.cs" />
+  </ItemGroup>
 
   <Target Name="NpmInstall" BeforeTargets="DispatchToInnerBuilds" Condition=" '$(CI)' != '' OR !Exists('$(MSBuildThisFileDirectory)\node_modules') ">
     <Exec Command="npm install" ContinueOnError="true">
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
index e51f851fd4..343cec44c4 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
@@ -3,11 +3,9 @@
 using System.Collections.Concurrent;
 using System.IO.Compression;
 using System.Reflection;
-
-using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Primitives;
 
-namespace Swashbuckle.AspNetCore.SwaggerUI;
+namespace Microsoft.Extensions.FileProviders;
 
 /// <summary>
 /// a <see cref="EmbeddedFileProvider"/> wrapper to provider gzip decompressed resource file info
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
index e94931461f..c925146613 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Options;
 using System.Reflection;
 using System.Security.Cryptography;
+using Microsoft.Extensions.FileProviders;
 
 #if NET
 using System.Diagnostics.CodeAnalysis;
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
index 39dfb18c47..e78a8c7c62 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
@@ -15,10 +15,6 @@
     <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
-  <ItemGroup>
-    <InternalsVisibleTo Include="Swashbuckle.AspNetCore.IntegrationTests" Key="00240000048000009400000006020000002400005253413100040000010001000b80d002f0437a94c4f6d77dfc29ce54df1040f66374cb7122ec5ddab3907a6dfe609a07ffd49b9aa6731fe3f8de4da7979ddea73e949c86effc4bec3f469cc36e788cf58c42c4be755efd1afd996ccab9f0db3455b834219f6614d00fe0410cc307c4eced320fd65fcc501f135dc537d7d09dcc1d2a572d24f8459a86469ec5" />
-  </ItemGroup>
-  
   <ItemGroup>
     <CompressedEmbeddedResource Include="node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" GeneratedFileSuffix="None" />
     <None Remove="index.html;index.js" />
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
index f14cafb8cb..6daa4ea801 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
@@ -1,4 +1,5 @@
 using System.Net;
+using System.Security.Cryptography;
 using Microsoft.AspNetCore.Builder;
 using Swashbuckle.AspNetCore.ReDoc;
 using ReDocApp = ReDoc;
@@ -162,4 +163,22 @@ public void ReDocOptions_Extensions()
         Assert.True(options.ConfigObject.SortPropsAlphabetically);
         Assert.True(options.ConfigObject.UntrustedSpec);
     }
+
+    [Fact]
+    public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
+    {
+        var site = new TestSite(typeof(ReDocApp.Startup));
+        using var client = site.BuildClient();
+
+        var diskFile ="redoc/bundles/redoc.standalone.js";
+        var diskFileName = Path.GetFileName("redoc/bundles/redoc.standalone.js");
+
+        using var htmlResponse = await client.GetAsync("/Api-Docs/redoc.standalone.js", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+
+        using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
+        using var diskFileStream = File.OpenRead(diskFile);
+
+        Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
+    }
 }
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index cbc89d5014..694c3b9a92 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -1,6 +1,6 @@
-using System.Net;
-using Microsoft.Extensions.FileProviders;
-using Swashbuckle.AspNetCore.SwaggerUI;
+using System.IO;
+using System.Net;
+using System.Security.Cryptography;
 
 namespace Swashbuckle.AspNetCore.IntegrationTests;
 
@@ -25,82 +25,6 @@ public async Task RoutePrefix_RedirectsToPathRelativeIndexUrl(
         Assert.Equal(expectedRedirectPath, response.Headers.Location.ToString());
     }
 
-    [Theory]
-    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules")]
-    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules.swagger_ui_dist")]
-    public void ResourceRead_CompressedEmbeddedFileProvider(string baseNamespace)
-    {
-        //confirm that GZipCompressedEmbeddedFileProvider is the same as EmbeddedFileProvider
-        var provider = new EmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
-        var compressedProvider = new GZipCompressedEmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
-        var checkSubpaths = new string[]
-        {
-            "/",
-            null,
-            string.Empty,
-            " ",
-            "\t",
-            "\n",
-            "/swagger_ui_dist",
-            "swagger_ui_dist",
-            "/nodir",
-            "nodir"
-        };
-
-        foreach (var subpath in checkSubpaths)
-        {
-            AssertResources(provider, compressedProvider, subpath);
-        }
-
-        var nonExistentFile = Guid.NewGuid().ToString();
-        AssertFileInfo(provider.GetFileInfo(nonExistentFile), compressedProvider.GetFileInfo(nonExistentFile));
-
-        static void AssertResources(IFileProvider expectedProvider, IFileProvider actualProvider, string subpath)
-        {
-            var expectedContents = expectedProvider.GetDirectoryContents(subpath);
-            var actualContents = actualProvider.GetDirectoryContents(subpath);
-
-            Assert.Equal(expectedContents.Exists, actualContents.Exists);
-            Assert.Equal(expectedContents.Count(), actualContents.Count());
-            var actualResourceMap = actualContents.ToDictionary(m => m.Name);
-
-            foreach (var expectedFileInfo in expectedContents)
-            {
-                Assert.True(actualResourceMap.TryGetValue(expectedFileInfo.Name, out var actualFileInfo));
-                Assert.NotNull(actualFileInfo);
-                Assert.True(actualFileInfo.Exists);
-                AssertFileInfo(expectedFileInfo, actualFileInfo);
-                AssertFileInfo(expectedProvider.GetFileInfo(expectedFileInfo.Name), actualProvider.GetFileInfo(expectedFileInfo.Name));
-            }
-        }
-
-        static void AssertFileInfo(IFileInfo expectedFileInfo, IFileInfo actualFileInfo)
-        {
-            Assert.Equal(expectedFileInfo.Exists, actualFileInfo.Exists);
-            Assert.Equal(expectedFileInfo.IsDirectory, actualFileInfo.IsDirectory);
-            Assert.Equal(expectedFileInfo.LastModified, actualFileInfo.LastModified);
-            Assert.Equal(expectedFileInfo.PhysicalPath, actualFileInfo.PhysicalPath);
-
-            if (expectedFileInfo.Exists && !expectedFileInfo.IsDirectory)
-            {
-                Assert.True(actualFileInfo.Length > 0);
-
-                using var stream = actualFileInfo.CreateReadStream();
-                Assert.NotNull(stream);
-                var buffer = new byte[256];
-                var readLength = stream.Read(buffer, 0, buffer.Length);
-                Assert.True(readLength > 0);
-                //we can check for correctness here
-            }
-            else
-            {
-                Assert.Equal(expectedFileInfo.Length, actualFileInfo.Length);
-                Assert.ThrowsAny<FileNotFoundException>(() => expectedFileInfo.CreateReadStream());
-                Assert.ThrowsAny<FileNotFoundException>(() => actualFileInfo.CreateReadStream());
-            }
-        }
-    }
-
     [Theory]
     [InlineData(typeof(Basic.Startup), "/index.html", "/swagger-ui.js", "/index.css", "/swagger-ui.css")]
     [InlineData(typeof(CustomUIConfig.Startup), "/swagger/index.html", "/swagger/swagger-ui.js", "swagger/index.css", "/swagger/swagger-ui.css")]
@@ -268,4 +192,24 @@ public async Task IndexUrl_Returns_ExpectedAssetPaths(
         Assert.Contains($"<script src=\"{scriptBundlePath}\" charset=\"utf-8\">", content);
         Assert.Contains($"<script src=\"{scriptPresetsPath}\" charset=\"utf-8\">", content);
     }
+
+    [Fact]
+    public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
+    {
+        var site = new TestSite(typeof(Basic.Startup));
+        using var client = site.BuildClient();
+
+        foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
+        {
+            var diskFileName = Path.GetFileName(diskFile);
+
+            using var htmlResponse = await client.GetAsync(diskFileName, TestContext.Current.CancellationToken);
+            Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+
+            using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
+            using var diskFileStream = File.OpenRead(diskFile);
+
+            Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
+        }
+    }
 }
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
index 9c8b424aa7..3ee5a2c439 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
@@ -42,6 +42,15 @@
     <PackageReference Include="xunit.v3" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="../../src/Swashbuckle.AspNetCore.SwaggerUI/node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/index.js;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*;**/*/LICENSE;**/*/NOTICE" Link="swagger-ui-dist/%(RecursiveDir)%(FileName)%(Extension)">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="../../src/Swashbuckle.AspNetCore.ReDoc/node_modules/redoc/bundles/redoc.standalone.js" Link="redoc/bundles/redoc.standalone.js">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+  
   <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">
     <PackageReference Update="Microsoft.AspNetCore.Mvc.Testing" VersionOverride="8.0.14" />
     <PackageReference Update="Microsoft.AspNetCore.TestHost" VersionOverride="8.0.14" />
diff --git a/test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs b/test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs
new file mode 100644
index 0000000000..4be35dd853
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs
@@ -0,0 +1,92 @@
+using System.Security.Cryptography;
+using Microsoft.Extensions.FileProviders;
+using Xunit;
+
+namespace Swashbuckle.AspNetCore.SwaggerUI.Test;
+
+/// <summary>
+/// For <see cref="GZipCompressedEmbeddedFileProvider"/> testing
+/// </summary>
+public class GZipCompressedEmbeddedFileProviderTests
+{
+    [Theory]
+    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules")]
+    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules.swagger_ui_dist")]
+    public void ResourceRead_CompressedEmbeddedFileProvider(string baseNamespace)
+    {
+        //confirm that GZipCompressedEmbeddedFileProvider is the same as EmbeddedFileProvider
+        var provider = new EmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
+        var compressedProvider = new GZipCompressedEmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
+        var checkSubpaths = new string[]
+        {
+            "/",
+            null,
+            string.Empty,
+            " ",
+            "\t",
+            "\n",
+            "/swagger_ui_dist",
+            "swagger_ui_dist",
+            "/nodir",
+            "nodir"
+        };
+
+        foreach (var subpath in checkSubpaths)
+        {
+            AssertResources(provider, compressedProvider, subpath);
+        }
+
+        var nonExistentFile = Guid.NewGuid().ToString();
+        AssertFileInfo(provider.GetFileInfo(nonExistentFile), compressedProvider.GetFileInfo(nonExistentFile));
+
+        static void AssertResources(IFileProvider expectedProvider, IFileProvider actualProvider, string subpath)
+        {
+            var expectedContents = expectedProvider.GetDirectoryContents(subpath);
+            var actualContents = actualProvider.GetDirectoryContents(subpath);
+
+            Assert.Equal(expectedContents.Exists, actualContents.Exists);
+            Assert.Equal(expectedContents.Count(), actualContents.Count());
+            var actualResourceMap = actualContents.ToDictionary(m => m.Name);
+
+            foreach (var expectedFileInfo in expectedContents)
+            {
+                Assert.True(actualResourceMap.TryGetValue(expectedFileInfo.Name, out var actualFileInfo));
+                Assert.NotNull(actualFileInfo);
+                Assert.True(actualFileInfo.Exists);
+                AssertFileInfo(expectedFileInfo, actualFileInfo);
+                AssertFileInfo(expectedProvider.GetFileInfo(expectedFileInfo.Name), actualProvider.GetFileInfo(expectedFileInfo.Name));
+            }
+        }
+
+        static void AssertFileInfo(IFileInfo expectedFileInfo, IFileInfo actualFileInfo)
+        {
+            Assert.Equal(expectedFileInfo.Exists, actualFileInfo.Exists);
+            Assert.Equal(expectedFileInfo.IsDirectory, actualFileInfo.IsDirectory);
+            Assert.Equal(expectedFileInfo.LastModified, actualFileInfo.LastModified);
+            Assert.Equal(expectedFileInfo.PhysicalPath, actualFileInfo.PhysicalPath);
+
+            if (expectedFileInfo.Exists && !expectedFileInfo.IsDirectory)
+            {
+                Assert.True(actualFileInfo.Length > 0);
+
+                using var stream = actualFileInfo.CreateReadStream();
+
+                var diskFileName = expectedFileInfo.Name.StartsWith("swagger_ui_dist.")
+                                   ? expectedFileInfo.Name.Substring("swagger_ui_dist.".Length)
+                                   : expectedFileInfo.Name;
+                var diskFile = Path.Combine("swagger-ui-dist", diskFileName);
+
+                Assert.True(File.Exists(diskFile));
+                using var diskFileStream = File.OpenRead(diskFile);
+
+                Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
+            }
+            else
+            {
+                Assert.Equal(expectedFileInfo.Length, actualFileInfo.Length);
+                Assert.ThrowsAny<FileNotFoundException>(() => expectedFileInfo.CreateReadStream());
+                Assert.ThrowsAny<FileNotFoundException>(() => actualFileInfo.CreateReadStream());
+            }
+        }
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj b/test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj
new file mode 100644
index 0000000000..bbcccf7d51
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\src\Swashbuckle.AspNetCore.SwaggerUI\GZipCompressedEmbeddedFileProvider.cs" Link="GZipCompressedEmbeddedFileProvider.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="../../src/Swashbuckle.AspNetCore.SwaggerUI/node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" Link="swagger-ui-dist/%(RecursiveDir)%(FileName)%(Extension)">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+    <PackageReference Include="xunit.v3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Swashbuckle.AspNetCore.SwaggerUI\Swashbuckle.AspNetCore.SwaggerUI.csproj" />
+  </ItemGroup>
+
+</Project>

From 9eb1cb1cd030a3b622735ea84997133070be8d99 Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Thu, 15 May 2025 23:12:15 +0800
Subject: [PATCH 03/16] Static assets now response with gzip directly if client
 supported

---
 Swashbuckle.AspNetCore.sln                    |   7 -
 .../ReDocMiddleware.cs                        |  38 +---
 .../Swashbuckle.AspNetCore.ReDoc.csproj       |   3 +-
 .../CompressedEmbeddedFileResponser.cs        | 186 ++++++++++++++++++
 .../GZipCompressedEmbeddedFileProvider.cs     | 141 -------------
 ...ttpContextAcceptEncodingCheckExtensions.cs |  64 ++++++
 .../SwaggerUIMiddleware.cs                    |  39 ++--
 .../ReDocIntegrationTests.cs                  |  32 ++-
 .../SwaggerUIIntegrationTests.cs              |  59 +++++-
 ...GZipCompressedEmbeddedFileProviderTests.cs |  92 ---------
 ...ashbuckle.AspNetCore.SwaggerUI.Test.csproj |  28 ---
 11 files changed, 353 insertions(+), 336 deletions(-)
 create mode 100644 src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs
 delete mode 100644 src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
 create mode 100644 src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs
 delete mode 100644 test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs
 delete mode 100644 test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj

diff --git a/Swashbuckle.AspNetCore.sln b/Swashbuckle.AspNetCore.sln
index f051e4b0fd..459bbf319f 100644
--- a/Swashbuckle.AspNetCore.sln
+++ b/Swashbuckle.AspNetCore.sln
@@ -126,8 +126,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "perf", "perf", "{0C7326F1-F
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Swashbuckle.AspNetCore.Benchmarks", "perf\Swashbuckle.AspNetCore.Benchmarks\Swashbuckle.AspNetCore.Benchmarks.csproj", "{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Swashbuckle.AspNetCore.SwaggerUI.Test", "test\Swashbuckle.AspNetCore.SwaggerUI.Test\Swashbuckle.AspNetCore.SwaggerUI.Test.csproj", "{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -286,10 +284,6 @@ Global
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13}.Release|Any CPU.Build.0 = Release|Any CPU
-		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -336,7 +330,6 @@ Global
 		{D06A88E8-6F42-4F40-943A-E266C0AE6EC9} = {DB3F57FC-1472-4F03-B551-43394DA3C5EB}
 		{F88B6070-BE3C-45F9-978C-2ECBA9518C24} = {DB3F57FC-1472-4F03-B551-43394DA3C5EB}
 		{28F5840B-AE87-46DB-9D83-C3C8C77C6A13} = {0C7326F1-F731-4CF9-8A98-80F39541D28F}
-		{7FB06619-0D8E-E106-C16B-8F72B7AAC16A} = {0ADCB223-F375-45AB-8BC4-834EC9C69554}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {36FC6A67-247D-4149-8EDD-79FFD1A75F51}
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
index 4f6ecaba90..62ca4f1307 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
@@ -2,20 +2,13 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
-using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.StaticFiles;
-using Microsoft.Extensions.FileProviders;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using System.Security.Cryptography;
 
 #if NET
 using System.Diagnostics.CodeAnalysis;
-using Microsoft.AspNetCore.Hosting;
 #else
 using System.Text.Json.Serialization;
-using IWebHostEnvironment = Microsoft.AspNetCore.Hosting.IHostingEnvironment;
 #endif
 
 namespace Swashbuckle.AspNetCore.ReDoc;
@@ -26,20 +19,19 @@ internal sealed class ReDocMiddleware
 
     private static readonly string ReDocVersion = GetReDocVersion();
 
+    private readonly RequestDelegate _next;
     private readonly ReDocOptions _options;
-    private readonly StaticFileMiddleware _staticFileMiddleware;
     private readonly JsonSerializerOptions _jsonSerializerOptions;
 
+    private readonly CompressedEmbeddedFileResponser _compressedEmbeddedFileResponser;
+
     public ReDocMiddleware(
         RequestDelegate next,
-        IWebHostEnvironment hostingEnv,
-        ILoggerFactory loggerFactory,
         ReDocOptions options)
     {
+        _next = next ?? throw new ArgumentNullException(nameof(next));
         _options = options ?? new ReDocOptions();
 
-        _staticFileMiddleware = CreateStaticFileMiddleware(next, hostingEnv, loggerFactory, options);
-
         if (options.JsonSerializerOptions != null)
         {
             _jsonSerializerOptions = options.JsonSerializerOptions;
@@ -55,6 +47,9 @@ public ReDocMiddleware(
             };
         }
 #endif
+
+        var pathPrefix = options.RoutePrefix.StartsWith("/") ? options.RoutePrefix : $"/{options.RoutePrefix}";
+        _compressedEmbeddedFileResponser = new(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
     }
 
     public async Task Invoke(HttpContext httpContext)
@@ -91,23 +86,10 @@ public async Task Invoke(HttpContext httpContext)
             }
         }
 
-        await _staticFileMiddleware.Invoke(httpContext);
-    }
-
-    private static StaticFileMiddleware CreateStaticFileMiddleware(
-        RequestDelegate next,
-        IWebHostEnvironment hostingEnv,
-        ILoggerFactory loggerFactory,
-        ReDocOptions options)
-    {
-        var staticFileOptions = new StaticFileOptions
+        if (!await _compressedEmbeddedFileResponser.TryRespondWithFileAsync(httpContext))
         {
-            RequestPath = string.IsNullOrEmpty(options.RoutePrefix) ? string.Empty : $"/{options.RoutePrefix}",
-            FileProvider = new GZipCompressedEmbeddedFileProvider(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace),
-            OnPrepareResponse = (context) => SetCacheHeaders(context.Context.Response, options),
-        };
-
-        return new StaticFileMiddleware(next, hostingEnv, Options.Create(staticFileOptions), loggerFactory);
+            await _next(httpContext);
+        }
     }
 
     private static string GetReDocVersion()
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
index 6a28d7409c..a9b68c2636 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
+++ b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
@@ -56,7 +56,8 @@
   </ItemGroup>
   
   <ItemGroup>
-    <Compile Include="..\Swashbuckle.AspNetCore.SwaggerUI\GZipCompressedEmbeddedFileProvider.cs" Link="GZipCompressedEmbeddedFileProvider.cs" />
+    <Compile Include="..\Swashbuckle.AspNetCore.SwaggerUI\CompressedEmbeddedFileResponser.cs" Link="CompressedEmbeddedFileResponser.cs" />
+    <Compile Include="..\Swashbuckle.AspNetCore.SwaggerUI\HttpContextAcceptEncodingCheckExtensions.cs" Link="HttpContextAcceptEncodingCheckExtensions.cs" />
   </ItemGroup>
 
   <Target Name="NpmInstall" BeforeTargets="DispatchToInnerBuilds" Condition=" '$(CI)' != '' OR !Exists('$(MSBuildThisFileDirectory)\node_modules') ">
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs
new file mode 100644
index 0000000000..afda777017
--- /dev/null
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs
@@ -0,0 +1,186 @@
+#nullable enable
+
+using Microsoft.AspNetCore.Http;
+using System.Reflection;
+using Microsoft.AspNetCore.StaticFiles;
+using System.IO.Compression;
+using System.Security.Cryptography;
+using Microsoft.Net.Http.Headers;
+
+#if NET
+using System.Collections.Frozen;
+#endif
+
+namespace Swashbuckle.AspNetCore;
+
+internal class CompressedEmbeddedFileResponser
+{
+    private readonly Assembly _assembly;
+    private readonly string _cacheControlHeaderValue;
+    private readonly string _pathPrefix;
+    private readonly FileExtensionContentTypeProvider _contentTypeProvider = new();
+
+#if NET
+
+    private readonly FrozenDictionary<string, ResourceIndexCache> _resourceIndexes;
+#else
+    private readonly Dictionary<string, ResourceIndexCache> _resourceIndexes;
+#endif
+
+    public CompressedEmbeddedFileResponser(Assembly assembly, string resourceNamePrefix, string pathPrefix, TimeSpan? cacheLifetime)
+    {
+        _assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
+        _pathPrefix = string.IsNullOrWhiteSpace(pathPrefix)
+                      ? string.Empty
+                      : pathPrefix == "/"
+                        ? string.Empty
+                        : pathPrefix.TrimEnd('/');
+        _cacheControlHeaderValue = GetCacheControlHeaderValue(cacheLifetime);
+
+        var resourceIndexes = assembly.GetManifestResourceNames()
+                                      .Where(name => name.StartsWith(resourceNamePrefix, StringComparison.Ordinal))
+                                      .ToDictionary(name => name.Substring(resourceNamePrefix.Length), name => new ResourceIndexCache(name), StringComparer.Ordinal);
+
+#if NET
+        _resourceIndexes = resourceIndexes.ToFrozenDictionary();
+#else
+        _resourceIndexes = resourceIndexes;
+#endif
+    }
+
+    public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
+    {
+        var path = httpContext.Request.Path.Value?.ToString() ?? string.Empty;
+        if (!path.StartsWith(_pathPrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        path = path.Substring(_pathPrefix.Length).Replace('/', '.');
+
+        if (_resourceIndexes.TryGetValue(path, out var resourceIndexCache))
+        {
+            var contentType = GetContentType(resourceIndexCache);
+            var (etag, Length) = GetDecompressContentETag(resourceIndexCache);
+
+            var responseHeaders = httpContext.Response.Headers;
+#if NET
+            var ifNoneMatch = httpContext.Request.Headers.IfNoneMatch.ToString();
+#else
+            var ifNoneMatch = httpContext.Request.Headers["If-None-Match"].ToString();
+#endif
+            if (ifNoneMatch == etag)
+            {
+                httpContext.Response.StatusCode = StatusCodes.Status304NotModified;
+                return true;
+            }
+
+            var responseWithGZip = httpContext.IsGZipAccepted();
+            if (responseWithGZip)
+            {
+#if NET
+                responseHeaders.ContentEncoding = "gzip";
+#else
+                responseHeaders["Content-Encoding"] = "gzip";
+#endif
+            }
+
+#if NET
+            responseHeaders.ContentType = contentType;
+            responseHeaders.ETag = etag;
+            responseHeaders.CacheControl = _cacheControlHeaderValue;
+#else
+            responseHeaders["Content-Type"] = contentType;
+            responseHeaders["ETag"] = etag;
+            responseHeaders["Cache-Control"] = _cacheControlHeaderValue;
+#endif
+            using var stream = OpenResourceStream(resourceIndexCache);
+            if (responseWithGZip)
+            {
+                responseHeaders.ContentLength = stream.Length;
+                await stream.CopyToAsync(httpContext.Response.Body, 81320, httpContext.RequestAborted);
+            }
+            else
+            {
+                responseHeaders.ContentLength = Length;
+                using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
+                await gzipStream.CopyToAsync(httpContext.Response.Body, 81320, httpContext.RequestAborted);
+            }
+
+            return true;
+        }
+        return false;
+    }
+
+    private static string GetCacheControlHeaderValue(TimeSpan? cacheLifetime)
+    {
+        if (cacheLifetime is { } maxAge)
+        {
+            return new CacheControlHeaderValue()
+            {
+                MaxAge = maxAge,
+                Private = true,
+            }.ToString();
+        }
+        else
+        {
+            return new CacheControlHeaderValue()
+            {
+                NoCache = true,
+                NoStore = true,
+            }.ToString();
+        }
+    }
+
+    private string GetContentType(ResourceIndexCache resourceIndexCache)
+    {
+        return resourceIndexCache.ContentType
+               ?? (_contentTypeProvider.TryGetContentType(resourceIndexCache.ResourceName, out var contentTypeValue)
+                   ? contentTypeValue
+                   : "application/octet-stream");
+    }
+
+    private (string ETag, long DecompressContentLength) GetDecompressContentETag(ResourceIndexCache resourceIndexCache)
+    {
+        //Get decompress content and hash
+        if (resourceIndexCache.ETag != null
+            && resourceIndexCache.DecompressContentLength != null)
+        {
+            return (resourceIndexCache.ETag, resourceIndexCache.DecompressContentLength.Value);
+        }
+
+        using var stream = OpenResourceStream(resourceIndexCache);
+
+        using var memoryStream = new MemoryStream((int)stream.Length * 2);
+        using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
+        gzipStream.CopyTo(memoryStream);
+        memoryStream.Seek(0, SeekOrigin.Begin);
+
+        resourceIndexCache.DecompressContentLength = memoryStream.Length;
+
+        using var md5 = MD5.Create();
+        var hashData = md5.ComputeHash(memoryStream);
+
+        resourceIndexCache.ETag = $"\"{Convert.ToBase64String(hashData)}\"";
+
+        return (resourceIndexCache.ETag, resourceIndexCache.DecompressContentLength.Value);
+    }
+
+    private Stream OpenResourceStream(ResourceIndexCache resourceIndexCache)
+    {
+        // Actually, since the name comes from GetManifestResourceNames(), the content can definitely be obtained
+        return _assembly.GetManifestResourceStream(resourceIndexCache.ResourceName)
+               ?? throw new InvalidOperationException($"Can not read resource \"{resourceIndexCache.ResourceName}\" in {_assembly}");
+    }
+
+    private class ResourceIndexCache(string resourceName)
+    {
+        public string? ETag { get; set; }
+
+        public string? ContentType { get; set; }
+
+        public long? DecompressContentLength { get; set; }
+
+        public string ResourceName { get; } = resourceName ?? throw new ArgumentNullException(nameof(resourceName));
+    }
+}
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
deleted file mode 100644
index 343cec44c4..0000000000
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/GZipCompressedEmbeddedFileProvider.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-using System.Buffers;
-using System.Collections;
-using System.Collections.Concurrent;
-using System.IO.Compression;
-using System.Reflection;
-using Microsoft.Extensions.Primitives;
-
-namespace Microsoft.Extensions.FileProviders;
-
-/// <summary>
-/// a <see cref="EmbeddedFileProvider"/> wrapper to provider gzip decompressed resource file info
-/// </summary>
-/// <param name="assembly"></param>
-/// <param name="baseNamespace"></param>
-internal sealed class GZipCompressedEmbeddedFileProvider(Assembly assembly, string baseNamespace) : IFileProvider
-{
-    private readonly string _baseNamespace = string.IsNullOrEmpty(baseNamespace) ? string.Empty : baseNamespace + ".";
-
-    private readonly EmbeddedFileProvider _embeddedFileProvider = new(assembly, baseNamespace);
-
-    private readonly ConcurrentDictionary<string, long> _subpathLengthCache = new(StringComparer.Ordinal);
-
-    /// <inheritdoc/>
-    public IDirectoryContents GetDirectoryContents(string subpath)
-    {
-        //logic same as EmbeddedFileProvider
-        return subpath?.Length == 0 || string.Equals(subpath, "/", StringComparison.Ordinal)
-               ? new DecompresDirectoryContents(EnumerateItems().ToList())
-               : new DecompresDirectoryContents([]);
-    }
-
-    /// <inheritdoc/>
-    public IFileInfo GetFileInfo(string subpath) => new GZipDecompresFileInfoWrapper(_embeddedFileProvider.GetFileInfo(subpath), subpath, GetSubpathDecompressedLength);
-
-    /// <inheritdoc/>
-    public IChangeToken Watch(string filter) => _embeddedFileProvider.Watch(filter);
-
-    private static string NormalizeSubPath(string subpath) => string.Join(".", subpath.Split(['/', '\\'], StringSplitOptions.RemoveEmptyEntries).Where(m => !string.IsNullOrWhiteSpace(m)));
-
-    /// <summary>
-    /// Get the <paramref name="stream"/>'s length by decompress and read it
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <returns></returns>
-    private static long ReadStreamDecompressedLength(Stream stream)
-    {
-        const int BufferSize = 4096;
-
-        long length = 0;
-        var buffer = ArrayPool<byte>.Shared.Rent(BufferSize);
-
-        try
-        {
-            using var gzipStream = new GZipStream(stream, CompressionMode.Decompress, true);
-            var readLength = 0;
-            do
-            {
-                readLength = gzipStream.Read(buffer, 0, BufferSize);
-                length += readLength;
-            } while (readLength != 0);
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(buffer);
-        }
-        return length;
-    }
-
-    private IEnumerable<IFileInfo> EnumerateItems()
-    {
-        return assembly.GetManifestResourceNames()
-                       .Where(name => name.StartsWith(_baseNamespace))
-                       .Select(name => name.Substring(_baseNamespace.Length))
-                       .Select(subpath => this.GetFileInfo(subpath))
-                       .Where(static fileInfo => fileInfo.Exists);
-    }
-
-    /// <summary>
-    /// Get <paramref name="subpath"/>'s decompressed length and cache it
-    /// </summary>
-    /// <param name="subpath"></param>
-    /// <returns></returns>
-    private long GetSubpathDecompressedLength(string subpath)
-    {
-        if (_subpathLengthCache.TryGetValue(subpath, out var length))
-        {
-            return length;
-        }
-
-        var resourceName = $"{_baseNamespace}{NormalizeSubPath(subpath)}";
-
-        using var stream = assembly.GetManifestResourceStream(resourceName);
-        if (stream == null)
-        {
-            return -1;
-        }
-
-        return _subpathLengthCache.GetOrAdd(subpath, _ => ReadStreamDecompressedLength(stream));
-    }
-
-    private sealed class DecompresDirectoryContents(List<IFileInfo> fileInfos) : IDirectoryContents
-    {
-        /// <inheritdoc/>
-        public bool Exists => fileInfos.Count > 0;
-
-        /// <inheritdoc/>
-        public IEnumerator<IFileInfo> GetEnumerator() => fileInfos.GetEnumerator();
-
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-    }
-
-    private sealed class GZipDecompresFileInfoWrapper(IFileInfo fileInfo, string subpath, Func<string, long> getSubpathLengthFunc) : IFileInfo
-    {
-        /// <inheritdoc/>
-        public bool Exists => fileInfo.Exists;
-
-        /// <inheritdoc/>
-        public bool IsDirectory => fileInfo.IsDirectory;
-
-        /// <inheritdoc/>
-        public DateTimeOffset LastModified => fileInfo.LastModified;
-
-        /// <inheritdoc/>
-        public long Length => fileInfo.Exists ? getSubpathLengthFunc(subpath) : -1;
-
-        /// <inheritdoc/>
-        public string Name => fileInfo.Name;
-
-        /// <inheritdoc/>
-        public string PhysicalPath => fileInfo.PhysicalPath;
-
-        /// <inheritdoc/>
-        public Stream CreateReadStream()
-        {
-            return fileInfo.CreateReadStream() is { } stream
-                   ? new GZipStream(stream, CompressionMode.Decompress)
-                   : throw new FileNotFoundException(message: null, fileName: fileInfo.Name);
-        }
-    }
-}
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs
new file mode 100644
index 0000000000..69fa537d5b
--- /dev/null
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs
@@ -0,0 +1,64 @@
+#nullable enable
+
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+
+namespace Swashbuckle.AspNetCore;
+
+/// <summary>
+/// <see cref="HttpContext"/> Accept-Encoding check extensions
+/// </summary>
+internal static partial class HttpContextAcceptEncodingCheckExtensions
+{
+#if NET
+    private static readonly Regex s_gzipAcceptedCheckRegex = GetGZipAcceptedCheckRegex();
+
+    [GeneratedRegex(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex GetGZipAcceptedCheckRegex();
+#else
+    private static readonly Regex s_gzipAcceptedCheckRegex = new(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+#endif
+
+    /// <summary>
+    /// Check is the <paramref name="httpContext"/> support gzip response
+    /// </summary>
+    /// <param name="httpContext"></param>
+    /// <returns>is gzip response accepted</returns>
+    public static bool IsGZipAccepted(this HttpContext httpContext)
+    {
+#if NET
+        return IsGZipAccepted(httpContext.Request.Headers.AcceptEncoding);
+#else
+        return IsGZipAccepted(httpContext.Request.Headers["Accept-Encoding"]);
+#endif
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsGZipAccepted(string? acceptEncoding) => !string.IsNullOrWhiteSpace(acceptEncoding) && s_gzipAcceptedCheckRegex.IsMatch(acceptEncoding);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsGZipAccepted(in StringValues acceptEncodingValues)
+    {
+        return acceptEncodingValues.Count switch
+        {
+            0 => false,
+            1 => IsGZipAccepted(acceptEncodingValues[0]),
+            _ => SlowCheckIsGZipAccepted(in acceptEncodingValues),
+        };
+    }
+
+    private static bool SlowCheckIsGZipAccepted(in StringValues values)
+    {
+        var valuesCount = values.Count;
+        for (var i = 0; i < valuesCount; i++)
+        {
+            if (IsGZipAccepted(values[i]))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
index c925146613..486f70b379 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
@@ -1,21 +1,14 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
-using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.StaticFiles;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using System.Reflection;
 using System.Security.Cryptography;
-using Microsoft.Extensions.FileProviders;
 
 #if NET
 using System.Diagnostics.CodeAnalysis;
-using Microsoft.AspNetCore.Hosting;
 #else
 using System.Text.Json.Serialization;
-using IWebHostEnvironment = Microsoft.AspNetCore.Hosting.IHostingEnvironment;
 #endif
 
 namespace Swashbuckle.AspNetCore.SwaggerUI;
@@ -26,24 +19,24 @@ internal sealed partial class SwaggerUIMiddleware
 
     private static readonly string SwaggerUIVersion = GetSwaggerUIVersion();
 
+    private readonly RequestDelegate _next;
     private readonly SwaggerUIOptions _options;
-    private readonly StaticFileMiddleware _staticFileMiddleware;
     private readonly JsonSerializerOptions _jsonSerializerOptions;
 
+    private readonly CompressedEmbeddedFileResponser _compressedEmbeddedFileResponser;
+
     public SwaggerUIMiddleware(
         RequestDelegate next,
-        IWebHostEnvironment hostingEnv,
-        ILoggerFactory loggerFactory,
         SwaggerUIOptions options)
     {
+        _next = next ?? throw new ArgumentNullException(nameof(next));
         _options = options ?? new SwaggerUIOptions();
 
-        _staticFileMiddleware = CreateStaticFileMiddleware(next, hostingEnv, loggerFactory, options);
-
         if (options.JsonSerializerOptions != null)
         {
             _jsonSerializerOptions = options.JsonSerializerOptions;
         }
+
 #if !NET
         else
         {
@@ -55,6 +48,9 @@ public SwaggerUIMiddleware(
             };
         }
 #endif
+
+        var pathPrefix = options.RoutePrefix.StartsWith("/") ? options.RoutePrefix : $"/{options.RoutePrefix}";
+        _compressedEmbeddedFileResponser = new(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
     }
 
     public async Task Invoke(HttpContext httpContext)
@@ -98,23 +94,10 @@ public async Task Invoke(HttpContext httpContext)
             }
         }
 
-        await _staticFileMiddleware.Invoke(httpContext);
-    }
-
-    private static StaticFileMiddleware CreateStaticFileMiddleware(
-        RequestDelegate next,
-        IWebHostEnvironment hostingEnv,
-        ILoggerFactory loggerFactory,
-        SwaggerUIOptions options)
-    {
-        var staticFileOptions = new StaticFileOptions
+        if (!await _compressedEmbeddedFileResponser.TryRespondWithFileAsync(httpContext))
         {
-            RequestPath = string.IsNullOrEmpty(options.RoutePrefix) ? string.Empty : $"/{options.RoutePrefix}",
-            FileProvider = new GZipCompressedEmbeddedFileProvider(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace),
-            OnPrepareResponse = (context) => SetCacheHeaders(context.Context.Response, options),
-        };
-
-        return new StaticFileMiddleware(next, hostingEnv, Options.Create(staticFileOptions), loggerFactory);
+            await _next(httpContext);
+        }
     }
 
     private static string GetSwaggerUIVersion()
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
index 6daa4ea801..c768edcb56 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
@@ -1,4 +1,5 @@
-using System.Net;
+using System.IO.Compression;
+using System.Net;
 using System.Security.Cryptography;
 using Microsoft.AspNetCore.Builder;
 using Swashbuckle.AspNetCore.ReDoc;
@@ -33,13 +34,13 @@ public async Task IndexUrl_ReturnsEmbeddedVersionOfTheRedocUI()
 
         AssertResource(htmlResponse);
         AssertResource(cssResponse);
-        AssertResource(jsResponse);
+        AssertResource(jsResponse, false);
 
-        static void AssertResource(HttpResponseMessage response)
+        static void AssertResource(HttpResponseMessage response, bool weakETag = true)
         {
             Assert.Equal(HttpStatusCode.OK, response.StatusCode);
             Assert.NotNull(response.Headers.ETag);
-            Assert.True(response.Headers.ETag.IsWeak);
+            Assert.Equal(weakETag, response.Headers.ETag.IsWeak);
             Assert.NotEmpty(response.Headers.ETag.Tag);
             Assert.NotNull(response.Headers.CacheControl);
             Assert.True(response.Headers.CacheControl.Private);
@@ -170,7 +171,7 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
         var site = new TestSite(typeof(ReDocApp.Startup));
         using var client = site.BuildClient();
 
-        var diskFile ="redoc/bundles/redoc.standalone.js";
+        var diskFile = "redoc/bundles/redoc.standalone.js";
         var diskFileName = Path.GetFileName("redoc/bundles/redoc.standalone.js");
 
         using var htmlResponse = await client.GetAsync("/Api-Docs/redoc.standalone.js", TestContext.Current.CancellationToken);
@@ -181,4 +182,25 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
 
         Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
     }
+
+    [Fact]
+    public async Task ReDocMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
+    {
+        var site = new TestSite(typeof(ReDocApp.Startup));
+        using var client = site.BuildClient();
+
+        var diskFile = "redoc/bundles/redoc.standalone.js";
+        var diskFileName = Path.GetFileName("redoc/bundles/redoc.standalone.js");
+
+        using var requestMessage = new HttpRequestMessage(HttpMethod.Get, "/Api-Docs/redoc.standalone.js");
+        requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
+        using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+
+        using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
+        using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
+        using var diskFileStream = File.OpenRead(diskFile);
+
+        Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(gzipStream));
+    }
 }
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 694c3b9a92..e48f01859b 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO.Compression;
 using System.Net;
 using System.Security.Cryptography;
 
@@ -42,19 +42,19 @@ public async Task IndexUrl_ReturnsEmbeddedVersionOfTheSwaggerUI(
         AssertResource(htmlResponse);
 
         using var jsResponse = await client.GetAsync(swaggerUijsPath, TestContext.Current.CancellationToken);
-        AssertResource(jsResponse);
+        AssertResource(jsResponse, false);
 
         using var indexCss = await client.GetAsync(indexCssPath, TestContext.Current.CancellationToken);
-        AssertResource(indexCss);
+        AssertResource(indexCss, false);
 
         using var cssResponse = await client.GetAsync(swaggerUiCssPath, TestContext.Current.CancellationToken);
-        AssertResource(cssResponse);
+        AssertResource(cssResponse, false);
 
-        static void AssertResource(HttpResponseMessage response)
+        static void AssertResource(HttpResponseMessage response, bool weakETag = true)
         {
             Assert.Equal(HttpStatusCode.OK, response.StatusCode);
             Assert.NotNull(response.Headers.ETag);
-            Assert.True(response.Headers.ETag.IsWeak);
+            Assert.Equal(weakETag, response.Headers.ETag.IsWeak);
             Assert.NotEmpty(response.Headers.ETag.Tag);
             Assert.NotNull(response.Headers.CacheControl);
             Assert.True(response.Headers.CacheControl.Private);
@@ -212,4 +212,51 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
             Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
         }
     }
+
+    [Fact]
+    public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
+    {
+        var site = new TestSite(typeof(Basic.Startup));
+        using var client = site.BuildClient();
+
+        foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
+        {
+            var diskFileName = Path.GetFileName(diskFile);
+
+            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, diskFileName);
+            requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
+            using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
+            Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+
+            using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
+            using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
+            using var diskFileStream = File.OpenRead(diskFile);
+
+            Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(gzipStream));
+        }
+    }
+
+    [Fact]
+    public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified()
+    {
+        var site = new TestSite(typeof(Basic.Startup));
+        using var client = site.BuildClient();
+
+        foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
+        {
+            var diskFileName = Path.GetFileName(diskFile);
+
+            using var htmlResponse = await client.GetAsync(diskFileName, TestContext.Current.CancellationToken);
+            Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+            Assert.NotNull(htmlResponse.Headers.ETag?.Tag);
+
+            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, diskFileName);
+            requestMessage.Headers.IfNoneMatch.Add(new(htmlResponse.Headers.ETag?.Tag));
+            using var secondHtmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
+            Assert.Equal(HttpStatusCode.NotModified, secondHtmlResponse.StatusCode);
+
+            using var stream = await secondHtmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
+            Assert.Equal(0, stream.Length);
+        }
+    }
 }
diff --git a/test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs b/test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs
deleted file mode 100644
index 4be35dd853..0000000000
--- a/test/Swashbuckle.AspNetCore.SwaggerUI.Test/GZipCompressedEmbeddedFileProviderTests.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-using System.Security.Cryptography;
-using Microsoft.Extensions.FileProviders;
-using Xunit;
-
-namespace Swashbuckle.AspNetCore.SwaggerUI.Test;
-
-/// <summary>
-/// For <see cref="GZipCompressedEmbeddedFileProvider"/> testing
-/// </summary>
-public class GZipCompressedEmbeddedFileProviderTests
-{
-    [Theory]
-    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules")]
-    [InlineData("Swashbuckle.AspNetCore.SwaggerUI.node_modules.swagger_ui_dist")]
-    public void ResourceRead_CompressedEmbeddedFileProvider(string baseNamespace)
-    {
-        //confirm that GZipCompressedEmbeddedFileProvider is the same as EmbeddedFileProvider
-        var provider = new EmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
-        var compressedProvider = new GZipCompressedEmbeddedFileProvider(typeof(SwaggerUIOptions).Assembly, baseNamespace);
-        var checkSubpaths = new string[]
-        {
-            "/",
-            null,
-            string.Empty,
-            " ",
-            "\t",
-            "\n",
-            "/swagger_ui_dist",
-            "swagger_ui_dist",
-            "/nodir",
-            "nodir"
-        };
-
-        foreach (var subpath in checkSubpaths)
-        {
-            AssertResources(provider, compressedProvider, subpath);
-        }
-
-        var nonExistentFile = Guid.NewGuid().ToString();
-        AssertFileInfo(provider.GetFileInfo(nonExistentFile), compressedProvider.GetFileInfo(nonExistentFile));
-
-        static void AssertResources(IFileProvider expectedProvider, IFileProvider actualProvider, string subpath)
-        {
-            var expectedContents = expectedProvider.GetDirectoryContents(subpath);
-            var actualContents = actualProvider.GetDirectoryContents(subpath);
-
-            Assert.Equal(expectedContents.Exists, actualContents.Exists);
-            Assert.Equal(expectedContents.Count(), actualContents.Count());
-            var actualResourceMap = actualContents.ToDictionary(m => m.Name);
-
-            foreach (var expectedFileInfo in expectedContents)
-            {
-                Assert.True(actualResourceMap.TryGetValue(expectedFileInfo.Name, out var actualFileInfo));
-                Assert.NotNull(actualFileInfo);
-                Assert.True(actualFileInfo.Exists);
-                AssertFileInfo(expectedFileInfo, actualFileInfo);
-                AssertFileInfo(expectedProvider.GetFileInfo(expectedFileInfo.Name), actualProvider.GetFileInfo(expectedFileInfo.Name));
-            }
-        }
-
-        static void AssertFileInfo(IFileInfo expectedFileInfo, IFileInfo actualFileInfo)
-        {
-            Assert.Equal(expectedFileInfo.Exists, actualFileInfo.Exists);
-            Assert.Equal(expectedFileInfo.IsDirectory, actualFileInfo.IsDirectory);
-            Assert.Equal(expectedFileInfo.LastModified, actualFileInfo.LastModified);
-            Assert.Equal(expectedFileInfo.PhysicalPath, actualFileInfo.PhysicalPath);
-
-            if (expectedFileInfo.Exists && !expectedFileInfo.IsDirectory)
-            {
-                Assert.True(actualFileInfo.Length > 0);
-
-                using var stream = actualFileInfo.CreateReadStream();
-
-                var diskFileName = expectedFileInfo.Name.StartsWith("swagger_ui_dist.")
-                                   ? expectedFileInfo.Name.Substring("swagger_ui_dist.".Length)
-                                   : expectedFileInfo.Name;
-                var diskFile = Path.Combine("swagger-ui-dist", diskFileName);
-
-                Assert.True(File.Exists(diskFile));
-                using var diskFileStream = File.OpenRead(diskFile);
-
-                Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
-            }
-            else
-            {
-                Assert.Equal(expectedFileInfo.Length, actualFileInfo.Length);
-                Assert.ThrowsAny<FileNotFoundException>(() => expectedFileInfo.CreateReadStream());
-                Assert.ThrowsAny<FileNotFoundException>(() => actualFileInfo.CreateReadStream());
-            }
-        }
-    }
-}
diff --git a/test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj b/test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj
deleted file mode 100644
index bbcccf7d51..0000000000
--- a/test/Swashbuckle.AspNetCore.SwaggerUI.Test/Swashbuckle.AspNetCore.SwaggerUI.Test.csproj
+++ /dev/null
@@ -1,28 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="..\..\src\Swashbuckle.AspNetCore.SwaggerUI\GZipCompressedEmbeddedFileProvider.cs" Link="GZipCompressedEmbeddedFileProvider.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Include="../../src/Swashbuckle.AspNetCore.SwaggerUI/node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" Link="swagger-ui-dist/%(RecursiveDir)%(FileName)%(Extension)">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
-    <PackageReference Include="xunit.runner.visualstudio" />
-    <PackageReference Include="xunit.v3" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\Swashbuckle.AspNetCore.SwaggerUI\Swashbuckle.AspNetCore.SwaggerUI.csproj" />
-  </ItemGroup>
-
-</Project>

From 24cef15f82aa1a5b556423a55fb90fa169eae7ac Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Tue, 20 May 2025 22:35:33 +0800
Subject: [PATCH 04/16] Chore for embedded resource compression

---
 .../CompressedEmbeddedFileResponder.cs}       | 12 +++---
 ...ttpContextAcceptEncodingCheckExtensions.cs |  3 --
 .../ReDocMiddleware.cs                        |  6 +--
 .../Swashbuckle.AspNetCore.ReDoc.csproj       |  6 +--
 .../SwaggerUIMiddleware.cs                    |  6 +--
 .../Swashbuckle.AspNetCore.SwaggerUI.csproj   |  4 ++
 .../ReDocIntegrationTests.cs                  | 17 +++-----
 .../SwaggerUIIntegrationTests.cs              | 39 ++++++++++++-------
 ...hbuckle.AspNetCore.IntegrationTests.csproj |  8 +---
 9 files changed, 51 insertions(+), 50 deletions(-)
 rename src/{Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs => Shared/CompressedEmbeddedFileResponder.cs} (95%)
 rename src/{Swashbuckle.AspNetCore.SwaggerUI => Shared}/HttpContextAcceptEncodingCheckExtensions.cs (93%)

diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs b/src/Shared/CompressedEmbeddedFileResponder.cs
similarity index 95%
rename from src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs
rename to src/Shared/CompressedEmbeddedFileResponder.cs
index afda777017..f68cb91257 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/CompressedEmbeddedFileResponser.cs
+++ b/src/Shared/CompressedEmbeddedFileResponder.cs
@@ -13,7 +13,7 @@
 
 namespace Swashbuckle.AspNetCore;
 
-internal class CompressedEmbeddedFileResponser
+internal class CompressedEmbeddedFileResponder
 {
     private readonly Assembly _assembly;
     private readonly string _cacheControlHeaderValue;
@@ -27,7 +27,7 @@ internal class CompressedEmbeddedFileResponser
     private readonly Dictionary<string, ResourceIndexCache> _resourceIndexes;
 #endif
 
-    public CompressedEmbeddedFileResponser(Assembly assembly, string resourceNamePrefix, string pathPrefix, TimeSpan? cacheLifetime)
+    public CompressedEmbeddedFileResponder(Assembly assembly, string resourceNamePrefix, string pathPrefix, TimeSpan? cacheLifetime)
     {
         _assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
         _pathPrefix = string.IsNullOrWhiteSpace(pathPrefix)
@@ -98,13 +98,13 @@ public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
             if (responseWithGZip)
             {
                 responseHeaders.ContentLength = stream.Length;
-                await stream.CopyToAsync(httpContext.Response.Body, 81320, httpContext.RequestAborted);
+                await stream.CopyToAsync(httpContext.Response.Body, 81920, httpContext.RequestAborted);
             }
             else
             {
                 responseHeaders.ContentLength = Length;
                 using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
-                await gzipStream.CopyToAsync(httpContext.Response.Body, 81320, httpContext.RequestAborted);
+                await gzipStream.CopyToAsync(httpContext.Response.Body, 81920, httpContext.RequestAborted);
             }
 
             return true;
@@ -158,8 +158,8 @@ private string GetContentType(ResourceIndexCache resourceIndexCache)
 
         resourceIndexCache.DecompressContentLength = memoryStream.Length;
 
-        using var md5 = MD5.Create();
-        var hashData = md5.ComputeHash(memoryStream);
+        using var sha1 = SHA1.Create();
+        var hashData = sha1.ComputeHash(memoryStream);
 
         resourceIndexCache.ETag = $"\"{Convert.ToBase64String(hashData)}\"";
 
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
similarity index 93%
rename from src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs
rename to src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
index 69fa537d5b..bebe41644d 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/HttpContextAcceptEncodingCheckExtensions.cs
+++ b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
@@ -1,6 +1,5 @@
 #nullable enable
 
-using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
@@ -35,10 +34,8 @@ public static bool IsGZipAccepted(this HttpContext httpContext)
 #endif
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static bool IsGZipAccepted(string? acceptEncoding) => !string.IsNullOrWhiteSpace(acceptEncoding) && s_gzipAcceptedCheckRegex.IsMatch(acceptEncoding);
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static bool IsGZipAccepted(in StringValues acceptEncodingValues)
     {
         return acceptEncodingValues.Count switch
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
index 62ca4f1307..7b7b2c6ffa 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
@@ -23,7 +23,7 @@ internal sealed class ReDocMiddleware
     private readonly ReDocOptions _options;
     private readonly JsonSerializerOptions _jsonSerializerOptions;
 
-    private readonly CompressedEmbeddedFileResponser _compressedEmbeddedFileResponser;
+    private readonly CompressedEmbeddedFileResponder _compressedEmbeddedFileResponder;
 
     public ReDocMiddleware(
         RequestDelegate next,
@@ -49,7 +49,7 @@ public ReDocMiddleware(
 #endif
 
         var pathPrefix = options.RoutePrefix.StartsWith("/") ? options.RoutePrefix : $"/{options.RoutePrefix}";
-        _compressedEmbeddedFileResponser = new(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
+        _compressedEmbeddedFileResponder = new(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
     }
 
     public async Task Invoke(HttpContext httpContext)
@@ -86,7 +86,7 @@ public async Task Invoke(HttpContext httpContext)
             }
         }
 
-        if (!await _compressedEmbeddedFileResponser.TryRespondWithFileAsync(httpContext))
+        if (!await _compressedEmbeddedFileResponder.TryRespondWithFileAsync(httpContext))
         {
             await _next(httpContext);
         }
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
index a9b68c2636..afa8ba4444 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
+++ b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
@@ -54,10 +54,10 @@
     <AdditionalFiles Include="PublicAPI\$(_TargetFrameworkIdentifier)\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\$(_TargetFrameworkIdentifier)\PublicAPI.Unshipped.txt" />
   </ItemGroup>
-  
+
   <ItemGroup>
-    <Compile Include="..\Swashbuckle.AspNetCore.SwaggerUI\CompressedEmbeddedFileResponser.cs" Link="CompressedEmbeddedFileResponser.cs" />
-    <Compile Include="..\Swashbuckle.AspNetCore.SwaggerUI\HttpContextAcceptEncodingCheckExtensions.cs" Link="HttpContextAcceptEncodingCheckExtensions.cs" />
+    <Compile Include="..\Shared\CompressedEmbeddedFileResponder.cs" Link="CompressedEmbeddedFileResponder.cs" />
+    <Compile Include="..\Shared\HttpContextAcceptEncodingCheckExtensions.cs" Link="HttpContextAcceptEncodingCheckExtensions.cs" />
   </ItemGroup>
 
   <Target Name="NpmInstall" BeforeTargets="DispatchToInnerBuilds" Condition=" '$(CI)' != '' OR !Exists('$(MSBuildThisFileDirectory)\node_modules') ">
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
index 486f70b379..aca878aa9c 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
@@ -23,7 +23,7 @@ internal sealed partial class SwaggerUIMiddleware
     private readonly SwaggerUIOptions _options;
     private readonly JsonSerializerOptions _jsonSerializerOptions;
 
-    private readonly CompressedEmbeddedFileResponser _compressedEmbeddedFileResponser;
+    private readonly CompressedEmbeddedFileResponder _compressedEmbeddedFileResponder;
 
     public SwaggerUIMiddleware(
         RequestDelegate next,
@@ -50,7 +50,7 @@ public SwaggerUIMiddleware(
 #endif
 
         var pathPrefix = options.RoutePrefix.StartsWith("/") ? options.RoutePrefix : $"/{options.RoutePrefix}";
-        _compressedEmbeddedFileResponser = new(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
+        _compressedEmbeddedFileResponder = new(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
     }
 
     public async Task Invoke(HttpContext httpContext)
@@ -94,7 +94,7 @@ public async Task Invoke(HttpContext httpContext)
             }
         }
 
-        if (!await _compressedEmbeddedFileResponser.TryRespondWithFileAsync(httpContext))
+        if (!await _compressedEmbeddedFileResponder.TryRespondWithFileAsync(httpContext))
         {
             await _next(httpContext);
         }
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
index e78a8c7c62..3f03c57b79 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
@@ -48,6 +48,10 @@
     <AdditionalFiles Include="PublicAPI\$(_TargetFrameworkIdentifier)\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\$(_TargetFrameworkIdentifier)\PublicAPI.Unshipped.txt" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\Shared\CompressedEmbeddedFileResponder.cs" Link="CompressedEmbeddedFileResponder.cs" />
+    <Compile Include="..\Shared\HttpContextAcceptEncodingCheckExtensions.cs" Link="HttpContextAcceptEncodingCheckExtensions.cs" />
+  </ItemGroup>
 
   <Target Name="NpmInstall" BeforeTargets="DispatchToInnerBuilds" Condition=" '$(CI)' != '' OR !Exists('$(MSBuildThisFileDirectory)\node_modules') ">
     <Exec Command="npm install" ContinueOnError="true">
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
index c768edcb56..9738b17bff 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
@@ -34,7 +34,7 @@ public async Task IndexUrl_ReturnsEmbeddedVersionOfTheRedocUI()
 
         AssertResource(htmlResponse);
         AssertResource(cssResponse);
-        AssertResource(jsResponse, false);
+        AssertResource(jsResponse, weakETag: false);
 
         static void AssertResource(HttpResponseMessage response, bool weakETag = true)
         {
@@ -171,16 +171,13 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
         var site = new TestSite(typeof(ReDocApp.Startup));
         using var client = site.BuildClient();
 
-        var diskFile = "redoc/bundles/redoc.standalone.js";
-        var diskFileName = Path.GetFileName("redoc/bundles/redoc.standalone.js");
-
         using var htmlResponse = await client.GetAsync("/Api-Docs/redoc.standalone.js", TestContext.Current.CancellationToken);
         Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
 
         using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
-        using var diskFileStream = File.OpenRead(diskFile);
+        using var rawFileStream = typeof(ReDocIntegrationTests).Assembly.GetManifestResourceStream("Swashbuckle.AspNetCore.IntegrationTests.Embedded.ReDoc.redoc.standalone.js");
 
-        Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
+        Assert.Equal(SHA1.HashData(rawFileStream), SHA1.HashData(stream));
     }
 
     [Fact]
@@ -189,18 +186,16 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
         var site = new TestSite(typeof(ReDocApp.Startup));
         using var client = site.BuildClient();
 
-        var diskFile = "redoc/bundles/redoc.standalone.js";
-        var diskFileName = Path.GetFileName("redoc/bundles/redoc.standalone.js");
-
         using var requestMessage = new HttpRequestMessage(HttpMethod.Get, "/Api-Docs/redoc.standalone.js");
         requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
         using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
         Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+        Assert.Equal("gzip", htmlResponse.Content.Headers.ContentEncoding.Single());
 
         using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
         using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
-        using var diskFileStream = File.OpenRead(diskFile);
+        using var rawFileStream = typeof(ReDocIntegrationTests).Assembly.GetManifestResourceStream("Swashbuckle.AspNetCore.IntegrationTests.Embedded.ReDoc.redoc.standalone.js");
 
-        Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(gzipStream));
+        Assert.Equal(SHA1.HashData(rawFileStream), SHA1.HashData(gzipStream));
     }
 }
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index e48f01859b..c4f8b6a31e 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -42,13 +42,13 @@ public async Task IndexUrl_ReturnsEmbeddedVersionOfTheSwaggerUI(
         AssertResource(htmlResponse);
 
         using var jsResponse = await client.GetAsync(swaggerUijsPath, TestContext.Current.CancellationToken);
-        AssertResource(jsResponse, false);
+        AssertResource(jsResponse, weakETag: false);
 
         using var indexCss = await client.GetAsync(indexCssPath, TestContext.Current.CancellationToken);
-        AssertResource(indexCss, false);
+        AssertResource(indexCss, weakETag: false);
 
         using var cssResponse = await client.GetAsync(swaggerUiCssPath, TestContext.Current.CancellationToken);
-        AssertResource(cssResponse, false);
+        AssertResource(cssResponse, weakETag: false);
 
         static void AssertResource(HttpResponseMessage response, bool weakETag = true)
         {
@@ -209,7 +209,7 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
             using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
             using var diskFileStream = File.OpenRead(diskFile);
 
-            Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(stream));
+            Assert.Equal(SHA1.HashData(diskFileStream), SHA1.HashData(stream));
         }
     }
 
@@ -219,20 +219,21 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly
         var site = new TestSite(typeof(Basic.Startup));
         using var client = site.BuildClient();
 
-        foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
-        {
-            var diskFileName = Path.GetFileName(diskFile);
+        Assert.NotEmpty(EnumerateEmbeddedUIFiles());
 
-            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, diskFileName);
+        foreach (var (resourceName, fileName) in EnumerateEmbeddedUIFiles())
+        {
+            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
             requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
             using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
             Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
+            Assert.Equal("gzip", htmlResponse.Content.Headers.ContentEncoding.Single());
 
             using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
             using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
-            using var diskFileStream = File.OpenRead(diskFile);
+            using var diskFileStream = typeof(SwaggerUIIntegrationTests).Assembly.GetManifestResourceStream(resourceName);
 
-            Assert.Equal(MD5.HashData(diskFileStream), MD5.HashData(gzipStream));
+            Assert.Equal(SHA1.HashData(diskFileStream), SHA1.HashData(gzipStream));
         }
     }
 
@@ -242,15 +243,15 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified(
         var site = new TestSite(typeof(Basic.Startup));
         using var client = site.BuildClient();
 
-        foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
-        {
-            var diskFileName = Path.GetFileName(diskFile);
+        Assert.NotEmpty(EnumerateEmbeddedUIFiles());
 
-            using var htmlResponse = await client.GetAsync(diskFileName, TestContext.Current.CancellationToken);
+        foreach (var (_, fileName) in EnumerateEmbeddedUIFiles())
+        {
+            using var htmlResponse = await client.GetAsync(fileName, TestContext.Current.CancellationToken);
             Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
             Assert.NotNull(htmlResponse.Headers.ETag?.Tag);
 
-            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, diskFileName);
+            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
             requestMessage.Headers.IfNoneMatch.Add(new(htmlResponse.Headers.ETag?.Tag));
             using var secondHtmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
             Assert.Equal(HttpStatusCode.NotModified, secondHtmlResponse.StatusCode);
@@ -259,4 +260,12 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified(
             Assert.Equal(0, stream.Length);
         }
     }
+
+    private IEnumerable<(string ResourceName, string FileName)> EnumerateEmbeddedUIFiles()
+    {
+        const string ResourcePrefix = "Swashbuckle.AspNetCore.IntegrationTests.Embedded.SwaggerUI.";
+        return typeof(SwaggerUIIntegrationTests).Assembly.GetManifestResourceNames()
+                                                         .Where(name => name.StartsWith(ResourcePrefix))
+                                                         .Select(name => (name, name.Substring(ResourcePrefix.Length)));
+    }
 }
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
index 3ee5a2c439..ef7bb39a6f 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
@@ -43,12 +43,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="../../src/Swashbuckle.AspNetCore.SwaggerUI/node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/index.js;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*;**/*/LICENSE;**/*/NOTICE" Link="swagger-ui-dist/%(RecursiveDir)%(FileName)%(Extension)">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="../../src/Swashbuckle.AspNetCore.ReDoc/node_modules/redoc/bundles/redoc.standalone.js" Link="redoc/bundles/redoc.standalone.js">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
+    <EmbeddedResource Include="../../src/Swashbuckle.AspNetCore.SwaggerUI/node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/index.js;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*;**/*/LICENSE;**/*/NOTICE" Link="Embedded/SwaggerUI/%(RecursiveDir)%(FileName)%(Extension)" />
+    <EmbeddedResource Include="../../src/Swashbuckle.AspNetCore.ReDoc/node_modules/redoc/bundles/redoc.standalone.js" Link="Embedded/ReDoc/%(RecursiveDir)%(FileName)%(Extension)" />
   </ItemGroup>
   
   <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">

From e22a8eebc4c0d1a9e74686edbd3c9d1a3e824896 Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Sun, 15 Jun 2025 10:30:27 +0800
Subject: [PATCH 05/16] Remove netstandard support

---
 src/Shared/CompressedEmbeddedFileResponder.cs | 28 +------------------
 ...ttpContextAcceptEncodingCheckExtensions.cs |  9 +-----
 .../ReDocMiddleware.cs                        |  7 +----
 .../SwaggerUIMiddleware.cs                    |  7 ++---
 .../ReDocIntegrationTests.cs                  |  4 +--
 .../SwaggerUIIntegrationTests.cs              |  6 ++--
 6 files changed, 10 insertions(+), 51 deletions(-)

diff --git a/src/Shared/CompressedEmbeddedFileResponder.cs b/src/Shared/CompressedEmbeddedFileResponder.cs
index f68cb91257..2b823f9e84 100644
--- a/src/Shared/CompressedEmbeddedFileResponder.cs
+++ b/src/Shared/CompressedEmbeddedFileResponder.cs
@@ -6,10 +6,7 @@
 using System.IO.Compression;
 using System.Security.Cryptography;
 using Microsoft.Net.Http.Headers;
-
-#if NET
 using System.Collections.Frozen;
-#endif
 
 namespace Swashbuckle.AspNetCore;
 
@@ -19,13 +16,7 @@ internal class CompressedEmbeddedFileResponder
     private readonly string _cacheControlHeaderValue;
     private readonly string _pathPrefix;
     private readonly FileExtensionContentTypeProvider _contentTypeProvider = new();
-
-#if NET
-
     private readonly FrozenDictionary<string, ResourceIndexCache> _resourceIndexes;
-#else
-    private readonly Dictionary<string, ResourceIndexCache> _resourceIndexes;
-#endif
 
     public CompressedEmbeddedFileResponder(Assembly assembly, string resourceNamePrefix, string pathPrefix, TimeSpan? cacheLifetime)
     {
@@ -41,11 +32,7 @@ public CompressedEmbeddedFileResponder(Assembly assembly, string resourceNamePre
                                       .Where(name => name.StartsWith(resourceNamePrefix, StringComparison.Ordinal))
                                       .ToDictionary(name => name.Substring(resourceNamePrefix.Length), name => new ResourceIndexCache(name), StringComparer.Ordinal);
 
-#if NET
         _resourceIndexes = resourceIndexes.ToFrozenDictionary();
-#else
-        _resourceIndexes = resourceIndexes;
-#endif
     }
 
     public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
@@ -64,11 +51,7 @@ public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
             var (etag, Length) = GetDecompressContentETag(resourceIndexCache);
 
             var responseHeaders = httpContext.Response.Headers;
-#if NET
             var ifNoneMatch = httpContext.Request.Headers.IfNoneMatch.ToString();
-#else
-            var ifNoneMatch = httpContext.Request.Headers["If-None-Match"].ToString();
-#endif
             if (ifNoneMatch == etag)
             {
                 httpContext.Response.StatusCode = StatusCodes.Status304NotModified;
@@ -78,22 +61,13 @@ public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
             var responseWithGZip = httpContext.IsGZipAccepted();
             if (responseWithGZip)
             {
-#if NET
                 responseHeaders.ContentEncoding = "gzip";
-#else
-                responseHeaders["Content-Encoding"] = "gzip";
-#endif
             }
 
-#if NET
             responseHeaders.ContentType = contentType;
             responseHeaders.ETag = etag;
             responseHeaders.CacheControl = _cacheControlHeaderValue;
-#else
-            responseHeaders["Content-Type"] = contentType;
-            responseHeaders["ETag"] = etag;
-            responseHeaders["Cache-Control"] = _cacheControlHeaderValue;
-#endif
+
             using var stream = OpenResourceStream(resourceIndexCache);
             if (responseWithGZip)
             {
diff --git a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
index bebe41644d..09536c525a 100644
--- a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
+++ b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
@@ -11,14 +11,11 @@ namespace Swashbuckle.AspNetCore;
 /// </summary>
 internal static partial class HttpContextAcceptEncodingCheckExtensions
 {
-#if NET
     private static readonly Regex s_gzipAcceptedCheckRegex = GetGZipAcceptedCheckRegex();
 
     [GeneratedRegex(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
     private static partial Regex GetGZipAcceptedCheckRegex();
-#else
-    private static readonly Regex s_gzipAcceptedCheckRegex = new(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
-#endif
+
 
     /// <summary>
     /// Check is the <paramref name="httpContext"/> support gzip response
@@ -27,11 +24,7 @@ internal static partial class HttpContextAcceptEncodingCheckExtensions
     /// <returns>is gzip response accepted</returns>
     public static bool IsGZipAccepted(this HttpContext httpContext)
     {
-#if NET
         return IsGZipAccepted(httpContext.Request.Headers.AcceptEncoding);
-#else
-        return IsGZipAccepted(httpContext.Request.Headers["Accept-Encoding"]);
-#endif
     }
 
     private static bool IsGZipAccepted(string? acceptEncoding) => !string.IsNullOrWhiteSpace(acceptEncoding) && s_gzipAcceptedCheckRegex.IsMatch(acceptEncoding);
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
index e0ffff7869..c0d988a666 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
@@ -1,15 +1,10 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Security.Cryptography;
 using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.StaticFiles;
-using Microsoft.Extensions.FileProviders;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using System.Security.Cryptography;
 
 namespace Swashbuckle.AspNetCore.ReDoc;
 
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
index 7d166cfe4a..f43a2e992f 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
@@ -1,13 +1,10 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Security.Cryptography;
 using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
-using System.Reflection;
-using System.Security.Cryptography;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Swashbuckle.AspNetCore.SwaggerUI;
 
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
index a0a668c7cb..480ae6df80 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
@@ -168,7 +168,7 @@ public void ReDocOptions_Extensions()
     [Fact]
     public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
     {
-        var site = new TestSite(typeof(ReDocApp.Startup));
+        var site = new TestSite(typeof(ReDocApp.Startup), outputHelper);
         using var client = site.BuildClient();
 
         using var htmlResponse = await client.GetAsync("/Api-Docs/redoc.standalone.js", TestContext.Current.CancellationToken);
@@ -183,7 +183,7 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
     [Fact]
     public async Task ReDocMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
     {
-        var site = new TestSite(typeof(ReDocApp.Startup));
+        var site = new TestSite(typeof(ReDocApp.Startup), outputHelper);
         using var client = site.BuildClient();
 
         using var requestMessage = new HttpRequestMessage(HttpMethod.Get, "/Api-Docs/redoc.standalone.js");
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 3953994bda..0f9a8c78ac 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -196,7 +196,7 @@ public async Task IndexUrl_Returns_ExpectedAssetPaths(
     [Fact]
     public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
     {
-        var site = new TestSite(typeof(Basic.Startup));
+        var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
         foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
@@ -216,7 +216,7 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
     [Fact]
     public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
     {
-        var site = new TestSite(typeof(Basic.Startup));
+        var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
         Assert.NotEmpty(EnumerateEmbeddedUIFiles());
@@ -240,7 +240,7 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly
     [Fact]
     public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified()
     {
-        var site = new TestSite(typeof(Basic.Startup));
+        var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
         Assert.NotEmpty(EnumerateEmbeddedUIFiles());

From 3f5e9e27ca7e10d16b4e01ac05591e88b84f06fa Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Sun, 15 Jun 2025 10:40:27 +0800
Subject: [PATCH 06/16] Embed compressed file using sdk task

---
 .../Swashbuckle.AspNetCore.ReDoc.csproj       | 28 +++++++++++++++----
 .../Swashbuckle.AspNetCore.SwaggerUI.csproj   | 28 +++++++++++++++----
 2 files changed, 46 insertions(+), 10 deletions(-)

diff --git a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
index ef3707bcce..026f5889e5 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
+++ b/src/Swashbuckle.AspNetCore.ReDoc/Swashbuckle.AspNetCore.ReDoc.csproj
@@ -22,7 +22,6 @@
     <EmbeddedResource Include="index.css" />
     <EmbeddedResource Include="index.html" />
     <EmbeddedResource Include="index.js" />
-    <CompressedEmbeddedResource Include="node_modules/redoc/bundles/redoc.standalone.js" GeneratedFileSuffix="None" />
   </ItemGroup>
 
   <ItemGroup>
@@ -31,10 +30,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
-    <PackageReference Include="ResourceCompressor">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
     <AdditionalFiles Include="PublicAPI\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\PublicAPI.Unshipped.txt" />
   </ItemGroup>
@@ -82,4 +77,27 @@
     </ItemGroup>
   </Target>
 
+  <!--embed compressed file using sdk task-->
+  <PropertyGroup>
+    <_SdkTasksTFM Condition=" '$(MSBuildRuntimeType)' == 'Core'">net9.0</_SdkTasksTFM>
+    <_SdkTasksTFM Condition=" '$(MSBuildRuntimeType)' != 'Core'">net472</_SdkTasksTFM>
+  </PropertyGroup>
+
+  <UsingTask TaskName="Microsoft.NET.Sdk.BlazorWebAssembly.GzipCompress"
+             AssemblyFile="$(MicrosoftNETBuildTasksDirectoryRoot)../../Microsoft.NET.Sdk.BlazorWebAssembly/tools/$(_SdkTasksTFM)/Microsoft.NET.Sdk.BlazorWebAssembly.Tasks.dll" />
+
+  <ItemGroup>
+    <CompressFiles Include="node_modules/redoc/bundles/redoc.standalone.js" />
+  </ItemGroup>
+
+  <Target Name="_CompressAssets" BeforeTargets="CheckForDuplicateItems">
+    <GZipCompress FilesToCompress="@(CompressFiles)" OutputDirectory="$(IntermediateOutputPath)CompressedAssets">
+      <Output TaskParameter="CompressedFiles" ItemName="_CompressedAssetsFile" />
+    </GZipCompress>
+
+    <ItemGroup>
+      <EmbeddedResource Include="@(_CompressedAssetsFile)" />
+      <EmbeddedResource Condition="'%(EmbeddedResource.OriginalItemSpec)' != ''" Link="%(EmbeddedResource.OriginalItemSpec)" />
+    </ItemGroup>
+  </Target>
 </Project>
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
index 80435d2616..3baa21f11a 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
@@ -14,7 +14,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <CompressedEmbeddedResource Include="node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" GeneratedFileSuffix="None" />
     <None Remove="index.html;index.js" />
     <EmbeddedResource Include="index.html;index.js" />
   </ItemGroup>
@@ -25,10 +24,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
-    <PackageReference Include="ResourceCompressor">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
     <AdditionalFiles Include="PublicAPI\PublicAPI.Shipped.txt" />
     <AdditionalFiles Include="PublicAPI\PublicAPI.Unshipped.txt" />
   </ItemGroup>
@@ -75,4 +70,27 @@
     </ItemGroup>
   </Target>
 
+  <!--embed compressed file using sdk task-->
+  <PropertyGroup>
+    <_SdkTasksTFM Condition=" '$(MSBuildRuntimeType)' == 'Core'">net9.0</_SdkTasksTFM>
+    <_SdkTasksTFM Condition=" '$(MSBuildRuntimeType)' != 'Core'">net472</_SdkTasksTFM>
+  </PropertyGroup>
+
+  <UsingTask TaskName="Microsoft.NET.Sdk.BlazorWebAssembly.GzipCompress"
+             AssemblyFile="$(MicrosoftNETBuildTasksDirectoryRoot)../../Microsoft.NET.Sdk.BlazorWebAssembly/tools/$(_SdkTasksTFM)/Microsoft.NET.Sdk.BlazorWebAssembly.Tasks.dll" />
+
+  <ItemGroup>
+    <CompressFiles Include="node_modules/swagger-ui-dist/**/*" Exclude="**/*/index.html;**/*/*.map;**/*/*.json;**/*/*.md;**/*/swagger-ui-es-*" />
+  </ItemGroup>
+
+  <Target Name="_CompressAssets" BeforeTargets="CheckForDuplicateItems">
+    <GZipCompress FilesToCompress="@(CompressFiles)" OutputDirectory="$(IntermediateOutputPath)CompressedAssets">
+      <Output TaskParameter="CompressedFiles" ItemName="_CompressedAssetsFile" />
+    </GZipCompress>
+
+    <ItemGroup>
+      <EmbeddedResource Include="@(_CompressedAssetsFile)" />
+      <EmbeddedResource Condition="'%(EmbeddedResource.OriginalItemSpec)' != ''" Link="%(EmbeddedResource.OriginalItemSpec)" />
+    </ItemGroup>
+  </Target>
 </Project>

From 7cf2bf8f88b8d6214de3ff00e6fc5fb6fe7b799b Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Sun, 15 Jun 2025 11:00:36 +0800
Subject: [PATCH 07/16] Fix SwaggerUIMiddleware test

---
 .../SwaggerUIIntegrationTests.cs                         | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 0f9a8c78ac..3301a76751 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -199,15 +199,14 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
         var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
-        foreach (var diskFile in Directory.EnumerateFiles("swagger-ui-dist"))
+        foreach (var (resourceName, fileName) in EnumerateEmbeddedUIFiles())
         {
-            var diskFileName = Path.GetFileName(diskFile);
-
-            using var htmlResponse = await client.GetAsync(diskFileName, TestContext.Current.CancellationToken);
+            using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
+            using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
             Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
 
             using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
-            using var diskFileStream = File.OpenRead(diskFile);
+            using var diskFileStream = typeof(SwaggerUIIntegrationTests).Assembly.GetManifestResourceStream(resourceName);
 
             Assert.Equal(SHA1.HashData(diskFileStream), SHA1.HashData(stream));
         }

From e5a585aad408883d5141555bbf23597858e5d4ce Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:16:27 +0800
Subject: [PATCH 08/16] Update
 test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 .../Swashbuckle.AspNetCore.IntegrationTests.csproj            | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
index 86267ab530..05094f0877 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
@@ -30,8 +30,8 @@
   </ItemGroup>
   
   <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">
-    <PackageReference Update="Microsoft.AspNetCore.Mvc.Testing" VersionOverride="8.0.14" />
-    <PackageReference Update="Microsoft.AspNetCore.TestHost" VersionOverride="8.0.14" />
+    <PackageReference Update="Microsoft.AspNetCore.Mvc.Testing" VersionOverride="8.0.17" />
+    <PackageReference Update="Microsoft.AspNetCore.TestHost" VersionOverride="8.0.17" />
   </ItemGroup>
 
   <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">

From 3734eb5e0917509abe7aacf0c7b7af8063bf1256 Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:16:37 +0800
Subject: [PATCH 09/16] Update
 test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 .../SwaggerUIIntegrationTests.cs                       | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 3301a76751..2cd4718514 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -260,11 +260,13 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified(
         }
     }
 
-    private IEnumerable<(string ResourceName, string FileName)> EnumerateEmbeddedUIFiles()
+    private static List<(string ResourceName, string FileName)> GetEmbeddedUIFiles()
     {
         const string ResourcePrefix = "Swashbuckle.AspNetCore.IntegrationTests.Embedded.SwaggerUI.";
-        return typeof(SwaggerUIIntegrationTests).Assembly.GetManifestResourceNames()
-                                                         .Where(name => name.StartsWith(ResourcePrefix))
-                                                         .Select(name => (name, name.Substring(ResourcePrefix.Length)));
+        return typeof(SwaggerUIIntegrationTests).Assembly
+            .GetManifestResourceNames()
+            .Where(name => name.StartsWith(ResourcePrefix))
+            .Select(name => (name, name.Substring(ResourcePrefix.Length)))
+            .ToList();
     }
 }

From 1b4e199d98130c24f00292f4cdd5dc764286c6d7 Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:17:35 +0800
Subject: [PATCH 10/16] Update
 test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 .../SwaggerUIIntegrationTests.cs                                 | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 2cd4718514..6f30bc10ba 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -252,6 +252,7 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified(
 
             using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
             requestMessage.Headers.IfNoneMatch.Add(new(htmlResponse.Headers.ETag?.Tag));
+
             using var secondHtmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
             Assert.Equal(HttpStatusCode.NotModified, secondHtmlResponse.StatusCode);
 

From c00bd4c30466fa0aa9e14e8dcc751c18a5870a1d Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:17:48 +0800
Subject: [PATCH 11/16] Update
 test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 .../SwaggerUIIntegrationTests.cs                                | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 6f30bc10ba..9b8a2b4e20 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -224,7 +224,9 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly
         {
             using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
             requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
+
             using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
+
             Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
             Assert.Equal("gzip", htmlResponse.Content.Headers.ContentEncoding.Single());
 

From db3881e11f6e89b0f9e3a955c89a60cf56c5dea4 Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:18:08 +0800
Subject: [PATCH 12/16] Update
 src/Shared/HttpContextAcceptEncodingCheckExtensions.cs

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 src/Shared/HttpContextAcceptEncodingCheckExtensions.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
index 09536c525a..7d9329ca17 100644
--- a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
+++ b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
@@ -16,7 +16,6 @@ internal static partial class HttpContextAcceptEncodingCheckExtensions
     [GeneratedRegex(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
     private static partial Regex GetGZipAcceptedCheckRegex();
 
-
     /// <summary>
     /// Check is the <paramref name="httpContext"/> support gzip response
     /// </summary>

From 5a91b1d3efcbfede5dbae373515e0735e7f10199 Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:18:30 +0800
Subject: [PATCH 13/16] Update
 src/Shared/HttpContextAcceptEncodingCheckExtensions.cs

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 src/Shared/HttpContextAcceptEncodingCheckExtensions.cs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
index 7d9329ca17..7012cb87e0 100644
--- a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
+++ b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
@@ -16,11 +16,6 @@ internal static partial class HttpContextAcceptEncodingCheckExtensions
     [GeneratedRegex(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
     private static partial Regex GetGZipAcceptedCheckRegex();
 
-    /// <summary>
-    /// Check is the <paramref name="httpContext"/> support gzip response
-    /// </summary>
-    /// <param name="httpContext"></param>
-    /// <returns>is gzip response accepted</returns>
     public static bool IsGZipAccepted(this HttpContext httpContext)
     {
         return IsGZipAccepted(httpContext.Request.Headers.AcceptEncoding);

From eb2550ee9acf3ecd39dbef1def92277071e37ef2 Mon Sep 17 00:00:00 2001
From: Stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:19:22 +0800
Subject: [PATCH 14/16] Update
 src/Shared/HttpContextAcceptEncodingCheckExtensions.cs

Co-authored-by: Martin Costello <martin@martincostello.com>
---
 src/Shared/HttpContextAcceptEncodingCheckExtensions.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
index 7012cb87e0..d7594df24f 100644
--- a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
+++ b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
@@ -6,9 +6,6 @@
 
 namespace Swashbuckle.AspNetCore;
 
-/// <summary>
-/// <see cref="HttpContext"/> Accept-Encoding check extensions
-/// </summary>
 internal static partial class HttpContextAcceptEncodingCheckExtensions
 {
     private static readonly Regex s_gzipAcceptedCheckRegex = GetGZipAcceptedCheckRegex();

From 887d9f0e0aab1eaca625b9f83dce53d3661d901d Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:36:47 +0800
Subject: [PATCH 15/16] Chore for PR

---
 src/Shared/CompressedEmbeddedFileResponder.cs | 113 +++++++++---------
 ...ttpContextAcceptEncodingCheckExtensions.cs |  33 +----
 .../ReDocMiddleware.cs                        |   2 +-
 .../SwaggerUIMiddleware.cs                    |   2 +-
 .../Swashbuckle.AspNetCore.SwaggerUI.csproj   |   2 +-
 .../ReDocIntegrationTests.cs                  |   3 +
 .../SwaggerUIIntegrationTests.cs              |  17 ++-
 7 files changed, 80 insertions(+), 92 deletions(-)

diff --git a/src/Shared/CompressedEmbeddedFileResponder.cs b/src/Shared/CompressedEmbeddedFileResponder.cs
index 2b823f9e84..152db8a181 100644
--- a/src/Shared/CompressedEmbeddedFileResponder.cs
+++ b/src/Shared/CompressedEmbeddedFileResponder.cs
@@ -1,38 +1,39 @@
 #nullable enable
 
-using Microsoft.AspNetCore.Http;
-using System.Reflection;
-using Microsoft.AspNetCore.StaticFiles;
+using System.Collections.Frozen;
 using System.IO.Compression;
+using System.Reflection;
 using System.Security.Cryptography;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.StaticFiles;
+using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
-using System.Collections.Frozen;
 
 namespace Swashbuckle.AspNetCore;
 
 internal class CompressedEmbeddedFileResponder
 {
     private readonly Assembly _assembly;
-    private readonly string _cacheControlHeaderValue;
-    private readonly string _pathPrefix;
+
+    private readonly StringValues _cacheControlHeaderValue;
+
     private readonly FileExtensionContentTypeProvider _contentTypeProvider = new();
-    private readonly FrozenDictionary<string, ResourceIndexCache> _resourceIndexes;
+
+    private readonly string _pathPrefix;
+
+    private readonly FrozenDictionary<string, ResourceIndexCache> _resourceMap;
 
     public CompressedEmbeddedFileResponder(Assembly assembly, string resourceNamePrefix, string pathPrefix, TimeSpan? cacheLifetime)
     {
         _assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
-        _pathPrefix = string.IsNullOrWhiteSpace(pathPrefix)
-                      ? string.Empty
-                      : pathPrefix == "/"
-                        ? string.Empty
-                        : pathPrefix.TrimEnd('/');
+        _pathPrefix = pathPrefix.TrimEnd('/');
         _cacheControlHeaderValue = GetCacheControlHeaderValue(cacheLifetime);
 
-        var resourceIndexes = assembly.GetManifestResourceNames()
-                                      .Where(name => name.StartsWith(resourceNamePrefix, StringComparison.Ordinal))
-                                      .ToDictionary(name => name.Substring(resourceNamePrefix.Length), name => new ResourceIndexCache(name), StringComparer.Ordinal);
+        var resourceMap = assembly.GetManifestResourceNames()
+                                  .Where(name => name.StartsWith(resourceNamePrefix, StringComparison.Ordinal))
+                                  .ToDictionary(name => name.Substring(resourceNamePrefix.Length), name => new ResourceIndexCache(name), StringComparer.Ordinal);
 
-        _resourceIndexes = resourceIndexes.ToFrozenDictionary();
+        _resourceMap = resourceMap.ToFrozenDictionary();
     }
 
     public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
@@ -45,45 +46,46 @@ public async Task<bool> TryRespondWithFileAsync(HttpContext httpContext)
 
         path = path.Substring(_pathPrefix.Length).Replace('/', '.');
 
-        if (_resourceIndexes.TryGetValue(path, out var resourceIndexCache))
+        if (!_resourceMap.TryGetValue(path, out var resourceIndexCache))
         {
-            var contentType = GetContentType(resourceIndexCache);
-            var (etag, Length) = GetDecompressContentETag(resourceIndexCache);
+            return false;
+        }
 
-            var responseHeaders = httpContext.Response.Headers;
-            var ifNoneMatch = httpContext.Request.Headers.IfNoneMatch.ToString();
-            if (ifNoneMatch == etag)
-            {
-                httpContext.Response.StatusCode = StatusCodes.Status304NotModified;
-                return true;
-            }
+        var contentType = GetContentType(resourceIndexCache);
+        var (etag, Length) = GetDecompressContentETag(resourceIndexCache);
 
-            var responseWithGZip = httpContext.IsGZipAccepted();
-            if (responseWithGZip)
-            {
-                responseHeaders.ContentEncoding = "gzip";
-            }
+        var responseHeaders = httpContext.Response.Headers;
+        var ifNoneMatch = httpContext.Request.Headers.IfNoneMatch.ToString();
+        if (ifNoneMatch == etag)
+        {
+            httpContext.Response.StatusCode = StatusCodes.Status304NotModified;
+            return true;
+        }
 
-            responseHeaders.ContentType = contentType;
-            responseHeaders.ETag = etag;
-            responseHeaders.CacheControl = _cacheControlHeaderValue;
+        var responseWithGZip = httpContext.IsGZipAccepted();
+        if (responseWithGZip)
+        {
+            responseHeaders.ContentEncoding = "gzip";
+        }
 
-            using var stream = OpenResourceStream(resourceIndexCache);
-            if (responseWithGZip)
-            {
-                responseHeaders.ContentLength = stream.Length;
-                await stream.CopyToAsync(httpContext.Response.Body, 81920, httpContext.RequestAborted);
-            }
-            else
-            {
-                responseHeaders.ContentLength = Length;
-                using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
-                await gzipStream.CopyToAsync(httpContext.Response.Body, 81920, httpContext.RequestAborted);
-            }
+        responseHeaders.ContentType = contentType;
+        responseHeaders.ETag = etag;
+        responseHeaders.CacheControl = _cacheControlHeaderValue;
 
-            return true;
+        using var stream = OpenResourceStream(resourceIndexCache);
+        if (responseWithGZip)
+        {
+            responseHeaders.ContentLength = stream.Length;
+            await stream.CopyToAsync(httpContext.Response.Body, httpContext.RequestAborted);
         }
-        return false;
+        else
+        {
+            responseHeaders.ContentLength = Length;
+            using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
+            await gzipStream.CopyToAsync(httpContext.Response.Body, httpContext.RequestAborted);
+        }
+
+        return true;
     }
 
     private static string GetCacheControlHeaderValue(TimeSpan? cacheLifetime)
@@ -116,7 +118,6 @@ private string GetContentType(ResourceIndexCache resourceIndexCache)
 
     private (string ETag, long DecompressContentLength) GetDecompressContentETag(ResourceIndexCache resourceIndexCache)
     {
-        //Get decompress content and hash
         if (resourceIndexCache.ETag != null
             && resourceIndexCache.DecompressContentLength != null)
         {
@@ -132,8 +133,7 @@ private string GetContentType(ResourceIndexCache resourceIndexCache)
 
         resourceIndexCache.DecompressContentLength = memoryStream.Length;
 
-        using var sha1 = SHA1.Create();
-        var hashData = sha1.ComputeHash(memoryStream);
+        var hashData = SHA1.HashData(memoryStream);
 
         resourceIndexCache.ETag = $"\"{Convert.ToBase64String(hashData)}\"";
 
@@ -143,18 +143,17 @@ private string GetContentType(ResourceIndexCache resourceIndexCache)
     private Stream OpenResourceStream(ResourceIndexCache resourceIndexCache)
     {
         // Actually, since the name comes from GetManifestResourceNames(), the content can definitely be obtained
-        return _assembly.GetManifestResourceStream(resourceIndexCache.ResourceName)
-               ?? throw new InvalidOperationException($"Can not read resource \"{resourceIndexCache.ResourceName}\" in {_assembly}");
+        return _assembly.GetManifestResourceStream(resourceIndexCache.ResourceName)!;
     }
 
-    private class ResourceIndexCache(string resourceName)
+    private sealed class ResourceIndexCache(string resourceName)
     {
-        public string? ETag { get; set; }
-
         public string? ContentType { get; set; }
 
         public long? DecompressContentLength { get; set; }
 
-        public string ResourceName { get; } = resourceName ?? throw new ArgumentNullException(nameof(resourceName));
+        public string? ETag { get; set; }
+
+        public string ResourceName { get; } = resourceName;
     }
 }
diff --git a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
index d7594df24f..1e5979aa4a 100644
--- a/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
+++ b/src/Shared/HttpContextAcceptEncodingCheckExtensions.cs
@@ -1,45 +1,24 @@
 #nullable enable
 
-using System.Text.RegularExpressions;
 using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Primitives;
 
 namespace Swashbuckle.AspNetCore;
 
-internal static partial class HttpContextAcceptEncodingCheckExtensions
+internal static class HttpContextAcceptEncodingCheckExtensions
 {
-    private static readonly Regex s_gzipAcceptedCheckRegex = GetGZipAcceptedCheckRegex();
-
-    [GeneratedRegex(@"(^|,)\s*gzip\s*(;|,|$)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
-    private static partial Regex GetGZipAcceptedCheckRegex();
-
     public static bool IsGZipAccepted(this HttpContext httpContext)
     {
-        return IsGZipAccepted(httpContext.Request.Headers.AcceptEncoding);
-    }
-
-    private static bool IsGZipAccepted(string? acceptEncoding) => !string.IsNullOrWhiteSpace(acceptEncoding) && s_gzipAcceptedCheckRegex.IsMatch(acceptEncoding);
-
-    private static bool IsGZipAccepted(in StringValues acceptEncodingValues)
-    {
-        return acceptEncodingValues.Count switch
-        {
-            0 => false,
-            1 => IsGZipAccepted(acceptEncodingValues[0]),
-            _ => SlowCheckIsGZipAccepted(in acceptEncodingValues),
-        };
-    }
+        var acceptEncoding = httpContext.Request.Headers.AcceptEncoding;
 
-    private static bool SlowCheckIsGZipAccepted(in StringValues values)
-    {
-        var valuesCount = values.Count;
-        for (var i = 0; i < valuesCount; i++)
+        for (var index = 0; index < acceptEncoding.Count; index++)
         {
-            if (IsGZipAccepted(values[i]))
+            var stringValue = acceptEncoding[index].AsSpan();
+            if (stringValue.Contains("gzip", StringComparison.OrdinalIgnoreCase))
             {
                 return true;
             }
         }
+
         return false;
     }
 }
diff --git a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
index c0d988a666..1aeb8a5c3c 100644
--- a/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.ReDoc/ReDocMiddleware.cs
@@ -32,7 +32,7 @@ public ReDocMiddleware(
             _jsonSerializerOptions = options.JsonSerializerOptions;
         }
 
-        var pathPrefix = options.RoutePrefix.StartsWith("/") ? options.RoutePrefix : $"/{options.RoutePrefix}";
+        var pathPrefix = options.RoutePrefix.StartsWith('/') ? options.RoutePrefix : $"/{options.RoutePrefix}";
         _compressedEmbeddedFileResponder = new(typeof(ReDocMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
     }
 
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
index f43a2e992f..805118149c 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/SwaggerUIMiddleware.cs
@@ -32,7 +32,7 @@ public SwaggerUIMiddleware(
             _jsonSerializerOptions = options.JsonSerializerOptions;
         }
 
-        var pathPrefix = options.RoutePrefix.StartsWith("/") ? options.RoutePrefix : $"/{options.RoutePrefix}";
+        var pathPrefix = options.RoutePrefix.StartsWith('/') ? options.RoutePrefix : $"/{options.RoutePrefix}";
         _compressedEmbeddedFileResponder = new(typeof(SwaggerUIMiddleware).Assembly, EmbeddedFileNamespace, pathPrefix, _options.CacheLifetime);
     }
 
diff --git a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
index 3baa21f11a..f5e8f3045c 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
+++ b/src/Swashbuckle.AspNetCore.SwaggerUI/Swashbuckle.AspNetCore.SwaggerUI.csproj
@@ -70,7 +70,7 @@
     </ItemGroup>
   </Target>
 
-  <!--embed compressed file using sdk task-->
+  <!-- Embed compressed file using SDK task-->
   <PropertyGroup>
     <_SdkTasksTFM Condition=" '$(MSBuildRuntimeType)' == 'Core'">net9.0</_SdkTasksTFM>
     <_SdkTasksTFM Condition=" '$(MSBuildRuntimeType)' != 'Core'">net472</_SdkTasksTFM>
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
index 480ae6df80..9ec838910a 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/ReDocIntegrationTests.cs
@@ -177,6 +177,7 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents()
         using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
         using var rawFileStream = typeof(ReDocIntegrationTests).Assembly.GetManifestResourceStream("Swashbuckle.AspNetCore.IntegrationTests.Embedded.ReDoc.redoc.standalone.js");
 
+        Assert.NotNull(rawFileStream);
         Assert.Equal(SHA1.HashData(rawFileStream), SHA1.HashData(stream));
     }
 
@@ -188,6 +189,7 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
 
         using var requestMessage = new HttpRequestMessage(HttpMethod.Get, "/Api-Docs/redoc.standalone.js");
         requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
+
         using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
         Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);
         Assert.Equal("gzip", htmlResponse.Content.Headers.ContentEncoding.Single());
@@ -196,6 +198,7 @@ public async Task ReDocMiddleware_Returns_ExpectedAssetContents_GZipDirectly()
         using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
         using var rawFileStream = typeof(ReDocIntegrationTests).Assembly.GetManifestResourceStream("Swashbuckle.AspNetCore.IntegrationTests.Embedded.ReDoc.redoc.standalone.js");
 
+        Assert.NotNull(rawFileStream);
         Assert.Equal(SHA1.HashData(rawFileStream), SHA1.HashData(gzipStream));
     }
 }
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
index 9b8a2b4e20..a849941e5a 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerUIIntegrationTests.cs
@@ -199,7 +199,10 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
         var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
-        foreach (var (resourceName, fileName) in EnumerateEmbeddedUIFiles())
+        var embeddedUIFiles = GetEmbeddedUIFiles();
+        Assert.NotEmpty(embeddedUIFiles);
+
+        foreach (var (resourceName, fileName) in embeddedUIFiles)
         {
             using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
             using var htmlResponse = await client.SendAsync(requestMessage, TestContext.Current.CancellationToken);
@@ -208,6 +211,7 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents()
             using var stream = await htmlResponse.Content.ReadAsStreamAsync(TestContext.Current.CancellationToken);
             using var diskFileStream = typeof(SwaggerUIIntegrationTests).Assembly.GetManifestResourceStream(resourceName);
 
+            Assert.NotNull(diskFileStream);
             Assert.Equal(SHA1.HashData(diskFileStream), SHA1.HashData(stream));
         }
     }
@@ -218,9 +222,10 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly
         var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
-        Assert.NotEmpty(EnumerateEmbeddedUIFiles());
+        var embeddedUIFiles = GetEmbeddedUIFiles();
+        Assert.NotEmpty(embeddedUIFiles);
 
-        foreach (var (resourceName, fileName) in EnumerateEmbeddedUIFiles())
+        foreach (var (resourceName, fileName) in embeddedUIFiles)
         {
             using var requestMessage = new HttpRequestMessage(HttpMethod.Get, fileName);
             requestMessage.Headers.AcceptEncoding.Add(new("gzip"));
@@ -234,6 +239,7 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_GZipDirectly
             using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
             using var diskFileStream = typeof(SwaggerUIIntegrationTests).Assembly.GetManifestResourceStream(resourceName);
 
+            Assert.NotNull(diskFileStream);
             Assert.Equal(SHA1.HashData(diskFileStream), SHA1.HashData(gzipStream));
         }
     }
@@ -244,9 +250,10 @@ public async Task SwaggerUIMiddleware_Returns_ExpectedAssetContents_NotModified(
         var site = new TestSite(typeof(Basic.Startup), outputHelper);
         using var client = site.BuildClient();
 
-        Assert.NotEmpty(EnumerateEmbeddedUIFiles());
+        var embeddedUIFiles = GetEmbeddedUIFiles();
+        Assert.NotEmpty(embeddedUIFiles);
 
-        foreach (var (_, fileName) in EnumerateEmbeddedUIFiles())
+        foreach (var (_, fileName) in embeddedUIFiles)
         {
             using var htmlResponse = await client.GetAsync(fileName, TestContext.Current.CancellationToken);
             Assert.Equal(HttpStatusCode.OK, htmlResponse.StatusCode);

From c951c4e1b01b19792710b28e9e1dc792a8873a0d Mon Sep 17 00:00:00 2001
From: stratos <stratosblue@outlook.com>
Date: Sat, 5 Jul 2025 15:39:30 +0800
Subject: [PATCH 16/16] remove unnecessary gitignore

---
 .gitignore | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 62b3baa1b6..0941846d76 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
-[Tt]est[Rr]esult*/
-.dotnet/
+.dotnet/
 .DS_Store
 .vs/
 .idea*