是否存在类似app.UseStaticFiles()的机制可在响应前修改文件内容？

针对你需要修改特定静态文件内容的需求，有几种实用的实现方式，具体如下：

一、自定义中间件拦截目标请求 #

这种方式最直接，先判断请求路径是否是你需要修改的文件，如果是则读取文件内容修改后返回，否则交给默认的静态文件中间件处理。

// 在Program.cs/Startup.cs中注册中间件，注意要放在UseStaticFiles之前
app.Use(async (context, next) =>
{
    var requestPath = context.Request.Path.Value?.ToLowerInvariant();
    // 根据实际文件路径调整匹配规则
    if (requestPath is "/foo.html" or "/bar.js")
    {
        var filePath = Path.Combine(env.WebRootPath, requestPath.TrimStart('/'));
        if (File.Exists(filePath))
        {
            string content = await File.ReadAllTextAsync(filePath);
            
            // 按文件类型执行修改逻辑
            if (requestPath == "/foo.html")
            {
                content = content.Replace("{{Placeholder}}", "针对Foo文件的修改内容");
            }
            else if (requestPath == "/bar.js")
            {
                content = content.Replace("const version = '1.0';", "const version = '2.0';");
            }
            
            // 设置正确的响应内容类型
            context.Response.ContentType = requestPath.EndsWith(".html") 
                ? "text/html; charset=utf-8" 
                : "application/javascript; charset=utf-8";
            await context.Response.WriteAsync(content);
            return; // 跳过后续中间件，直接返回修改后的内容
        }
    }
    // 非目标文件，交给下一个中间件处理
    await next();
});

// 正常注册静态文件中间件
app.UseStaticFiles();

二、自定义IFileProvider包装默认提供器 #

如果需要更深入地集成到静态文件处理流程中，可以实现自己的IFileProvider，包装默认的物理文件提供器，在读取文件内容时自动修改。

1. 实现自定义FileProvider和FileInfo #

public class ModifiedFileProvider : IFileProvider
{
    private readonly IFileProvider _innerProvider;
    private readonly IWebHostEnvironment _env;

    public ModifiedFileProvider(IFileProvider innerProvider, IWebHostEnvironment env)
    {
        _innerProvider = innerProvider;
        _env = env;
    }

    public IDirectoryContents GetDirectoryContents(string subpath)
        => _innerProvider.GetDirectoryContents(subpath);

    public IFileInfo GetFileInfo(string subpath)
    {
        var fileInfo = _innerProvider.GetFileInfo(subpath);
        if (!fileInfo.Exists) return fileInfo;

        // 匹配需要修改的文件名
        if (fileInfo.Name.Equals("foo.html", StringComparison.OrdinalIgnoreCase) || 
            fileInfo.Name.Equals("bar.js", StringComparison.OrdinalIgnoreCase))
        {
            return new ModifiedFileInfo(fileInfo);
        }

        return fileInfo;
    }

    public IChangeToken Watch(string filter)
        => _innerProvider.Watch(filter);
}

public class ModifiedFileInfo : IFileInfo
{
    private readonly IFileInfo _innerFileInfo;

    public ModifiedFileInfo(IFileInfo innerFileInfo)
    {
        _innerFileInfo = innerFileInfo;
    }

    // 委托IFileInfo的基础属性
    public bool Exists => _innerFileInfo.Exists;
    public long Length => GetModifiedContent().Length;
    public string PhysicalPath => _innerFileInfo.PhysicalPath;
    public string Name => _innerFileInfo.Name;
    public DateTimeOffset LastModified => _innerFileInfo.LastModified;
    public bool IsDirectory => _innerFileInfo.IsDirectory;

    public Stream CreateReadStream()
    {
        var modifiedContent = GetModifiedContent();
        return new MemoryStream(Encoding.UTF8.GetBytes(modifiedContent));
    }

    private string GetModifiedContent()
    {
        string content = File.ReadAllText(_innerFileInfo.PhysicalPath);
        
        // 按文件名执行修改逻辑
        if (Name.Equals("foo.html", StringComparison.OrdinalIgnoreCase))
        {
            content = content.Replace("旧的Foo内容", "修改后的Foo内容");
        }
        else if (Name.Equals("bar.js", StringComparison.OrdinalIgnoreCase))
        {
            content = content.Replace("console.log('bar')", "console.log('修改后的bar')");
        }

        return content;
    }
}

2. 注册自定义FileProvider #

var defaultProvider = env.WebRootFileProvider;
var modifiedProvider = new ModifiedFileProvider(defaultProvider, env);

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = modifiedProvider
});

三、拦截响应流批量修改 #

如果需要在响应发送前统一处理内容（不止特定文件），可以通过替换响应流的方式拦截并修改内容，适合场景更通用的情况。

app.Use(async (context, next) =>
{
    var originalResponseBody = context.Response.Body;
    using var memoryStream = new MemoryStream();
    context.Response.Body = memoryStream;

    await next();

    // 仅针对目标文件处理
    var requestPath = context.Request.Path.Value?.ToLowerInvariant();
    if (requestPath is "/foo.html" or "/bar.js")
    {
        memoryStream.Seek(0, SeekOrigin.Begin);
        var content = await new StreamReader(memoryStream).ReadToEndAsync();

        // 执行修改逻辑
        if (requestPath == "/foo.html")
        {
            content = content.Replace("{{PageTitle}}", "修改后的Foo页面标题");
        }
        else if (requestPath == "/bar.js")
        {
            content = content.Replace("var x = 10;", "var x = 20;");
        }

        // 将修改后的内容写回流
        memoryStream.SetLength(0);
        await new StreamWriter(memoryStream).WriteAsync(content);
        memoryStream.Seek(0, SeekOrigin.Begin);
    }

    // 将处理后的流复制回原始响应流
    await memoryStream.CopyToAsync(originalResponseBody);
    context.Response.Body = originalResponseBody;
});

app.UseStaticFiles();

内容的提问来源于stack exchange，提问作者Jez