1. 静态文件中间件 设置静态文件在浏览器缓存

var contentType = new FileExtensionContentTypeProvider();
//Mappings字典中包含常用mime头的,是在实例FileExtensionContentTypeProvider 调用FileExtensionContentTypeProvider(IDictionary<string, string> mapping)

//一般不需要手动指定
contentType.Mappings[".html"] = "text/html";   //字典key 为文件后缀名   value为文件对应mime头


app.UseStaticFiles(new StaticFileOptions()
{
    ContentTypeProvider = contentType,

    OnPrepareResponse = context =>
    {
        Console.WriteLine($"静态页面:{context.Context.Request.Path}");   //测试使用
        context.Context.Response.Headers["Cache-Control"] = $"public,max-age=7200";
    }
});

查看静态文件访问请求:

public FileExtensionContentTypeProvider()
    : this(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
    {
        { ".323", "text/h323" },
        { ".3g2", "video/3gpp2" },
        { ".3gp2", "video/3gpp2" },
        { ".3gp", "video/3gpp" },
        { ".3gpp", "video/3gpp" },
        { ".aac", "audio/aac" },
        { ".aaf", "application/octet-stream" },
        { ".aca", "application/octet-stream" },
        { ".accdb", "application/msaccess" },
        { ".accde", "application/msaccess" },
        { ".accdt", "application/msaccess" },
        { ".acx", "application/internet-property-stream" },
        { ".adt", "audio/vnd.dlna.adts" },
        { ".adts", "audio/vnd.dlna.adts" },
        { ".afm", "application/octet-stream" },
        { ".ai", "application/postscript" },
        { ".aif", "audio/x-aiff" },
        { ".aifc", "audio/aiff" },
        { ".aiff", "audio/aiff" },
        { ".appcache", "text/cache-manifest" },
        { ".application", "application/x-ms-application" },
        { ".art", "image/x-jg" },
        { ".asd", "application/octet-stream" },
        { ".asf", "video/x-ms-asf" },
        { ".asi", "application/octet-stream" },
        { ".asm", "text/plain" },
        { ".asr", "video/x-ms-asf" },
        { ".asx", "video/x-ms-asf" },
        { ".atom", "application/atom+xml" },
        { ".au", "audio/basic" },
        { ".avi", "video/x-msvideo" },
        { ".axs", "application/olescript" },
        { ".bas", "text/plain" },
        { ".bcpio", "application/x-bcpio" },
        { ".bin", "application/octet-stream" },
        { ".bmp", "image/bmp" },
        { ".c", "text/plain" },
        { ".cab", "application/vnd.ms-cab-compressed" },
        { ".calx", "application/vnd.ms-office.calx" },
        { ".cat", "application/vnd.ms-pki.seccat" },
        { ".cdf", "application/x-cdf" },
        { ".chm", "application/octet-stream" },
        { ".class", "application/x-java-applet" },
        { ".clp", "application/x-msclip" },
        { ".cmx", "image/x-cmx" },
        { ".cnf", "text/plain" },
        { ".cod", "image/cis-cod" },
        { ".cpio", "application/x-cpio" },
        { ".cpp", "text/plain" },
        { ".crd", "application/x-mscardfile" },
        { ".crl", "application/pkix-crl" },
        { ".crt", "application/x-x509-ca-cert" },
        { ".csh", "application/x-csh" },
        { ".css", "text/css" },
        { ".csv", "text/csv" }, // https://tools.ietf.org/html/rfc7111#section-5.1
        { ".cur", "application/octet-stream" },
        { ".dcr", "application/x-director" },
        { ".deploy", "application/octet-stream" },
        { ".der", "application/x-x509-ca-cert" },
        { ".dib", "image/bmp" },
        { ".dir", "application/x-director" },
        { ".disco", "text/xml" },
        { ".dlm", "text/dlm" },
        { ".doc", "application/msword" },
        { ".docm", "application/vnd.ms-word.document.macroEnabled.12" },
        { ".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
        { ".dot", "application/msword" },
        { ".dotm", "application/vnd.ms-word.template.macroEnabled.12" },
        { ".dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template" },
        { ".dsp", "application/octet-stream" },
        { ".dtd", "text/xml" },
        { ".dvi", "application/x-dvi" },
        { ".dvr-ms", "video/x-ms-dvr" },
        { ".dwf", "drawing/x-dwf" },
        { ".dwp", "application/octet-stream" },
        { ".dxr", "application/x-director" },
        { ".eml", "message/rfc822" },
        { ".emz", "application/octet-stream" },
        { ".eot", "application/vnd.ms-fontobject" },
        { ".eps", "application/postscript" },
        { ".etx", "text/x-setext" },
        { ".evy", "application/envoy" },
        { ".exe", "application/vnd.microsoft.portable-executable" }, // https://www.iana.org/assignments/media-types/application/vnd.microsoft.portable-executable
        { ".fdf", "application/vnd.fdf" },
        { ".fif", "application/fractals" },
        { ".fla", "application/octet-stream" },
        { ".flr", "x-world/x-vrml" },
        { ".flv", "video/x-flv" },
        { ".gif", "image/gif" },
        { ".gtar", "application/x-gtar" },
        { ".gz", "application/x-gzip" },
        { ".h", "text/plain" },
        { ".hdf", "application/x-hdf" },
        { ".hdml", "text/x-hdml" },
        { ".hhc", "application/x-oleobject" },
        { ".hhk", "application/octet-stream" },
        { ".hhp", "application/octet-stream" },
        { ".hlp", "application/winhlp" },
        { ".hqx", "application/mac-binhex40" },
        { ".hta", "application/hta" },
        { ".htc", "text/x-component" },
        { ".htm", "text/html" },
        { ".html", "text/html" },
        { ".htt", "text/webviewhtml" },
        { ".hxt", "text/html" },
        { ".ical", "text/calendar" },
        { ".icalendar", "text/calendar" },
        { ".ico", "image/x-icon" },
        { ".ics", "text/calendar" },
        { ".ief", "image/ief" },
        { ".ifb", "text/calendar" },
        { ".iii", "application/x-iphone" },
        { ".inf", "application/octet-stream" },
        { ".ins", "application/x-internet-signup" },
        { ".isp", "application/x-internet-signup" },
        { ".IVF", "video/x-ivf" },
        { ".jar", "application/java-archive" },
        { ".java", "application/octet-stream" },
        { ".jck", "application/liquidmotion" },
        { ".jcz", "application/liquidmotion" },
        { ".jfif", "image/pjpeg" },
        { ".jpb", "application/octet-stream" },
        { ".jpe", "image/jpeg" },
        { ".jpeg", "image/jpeg" },
        { ".jpg", "image/jpeg" },
        { ".js", "application/javascript" },
        { ".json", "application/json" },
        { ".jsx", "text/jscript" },
        { ".latex", "application/x-latex" },
        { ".lit", "application/x-ms-reader" },
        { ".lpk", "application/octet-stream" },
        { ".lsf", "video/x-la-asf" },
        { ".lsx", "video/x-la-asf" },
        { ".lzh", "application/octet-stream" },
        { ".m13", "application/x-msmediaview" },
        { ".m14", "application/x-msmediaview" },
        { ".m1v", "video/mpeg" },
        { ".m2ts", "video/vnd.dlna.mpeg-tts" },
        { ".m3u", "audio/x-mpegurl" },
        { ".m4a", "audio/mp4" },
        { ".m4v", "video/mp4" },
        { ".man", "application/x-troff-man" },
        { ".manifest", "application/x-ms-manifest" },
        { ".map", "text/plain" },
        { ".markdown", "text/markdown" },
        { ".md", "text/markdown" },
        { ".mdb", "application/x-msaccess" },
        { ".mdp", "application/octet-stream" },
        { ".me", "application/x-troff-me" },
        { ".mht", "message/rfc822" },
        { ".mhtml", "message/rfc822" },
        { ".mid", "audio/mid" },
        { ".midi", "audio/mid" },
        { ".mix", "application/octet-stream" },
        { ".mmf", "application/x-smaf" },
        { ".mno", "text/xml" },
        { ".mny", "application/x-msmoney" },
        { ".mov", "video/quicktime" },
        { ".movie", "video/x-sgi-movie" },
        { ".mp2", "video/mpeg" },
        { ".mp3", "audio/mpeg" },
        { ".mp4", "video/mp4" },
        { ".mp4v", "video/mp4" },
        { ".mpa", "video/mpeg" },
        { ".mpe", "video/mpeg" },
        { ".mpeg", "video/mpeg" },
        { ".mpg", "video/mpeg" },
        { ".mpp", "application/vnd.ms-project" },
        { ".mpv2", "video/mpeg" },
        { ".ms", "application/x-troff-ms" },
        { ".msi", "application/octet-stream" },
        { ".mso", "application/octet-stream" },
        { ".mvb", "application/x-msmediaview" },
        { ".mvc", "application/x-miva-compiled" },
        { ".nc", "application/x-netcdf" },
        { ".nsc", "video/x-ms-asf" },
        { ".nws", "message/rfc822" },
        { ".ocx", "application/octet-stream" },
        { ".oda", "application/oda" },
        { ".odc", "text/x-ms-odc" },
        { ".ods", "application/oleobject" },
        { ".oga", "audio/ogg" },
        { ".ogg", "video/ogg" },
        { ".ogv", "video/ogg" },
        { ".ogx", "application/ogg" },
        { ".one", "application/onenote" },
        { ".onea", "application/onenote" },
        { ".onetoc", "application/onenote" },
        { ".onetoc2", "application/onenote" },
        { ".onetmp", "application/onenote" },
        { ".onepkg", "application/onenote" },
        { ".osdx", "application/opensearchdescription+xml" },
        { ".otf", "font/otf" },
        { ".p10", "application/pkcs10" },
        { ".p12", "application/x-pkcs12" },
        { ".p7b", "application/x-pkcs7-certificates" },
        { ".p7c", "application/pkcs7-mime" },
        { ".p7m", "application/pkcs7-mime" },
        { ".p7r", "application/x-pkcs7-certreqresp" },
        { ".p7s", "application/pkcs7-signature" },
        { ".pbm", "image/x-portable-bitmap" },
        { ".pcx", "application/octet-stream" },
        { ".pcz", "application/octet-stream" },
        { ".pdf", "application/pdf" },
        { ".pfb", "application/octet-stream" },
        { ".pfm", "application/octet-stream" },
        { ".pfx", "application/x-pkcs12" },
        { ".pgm", "image/x-portable-graymap" },
        { ".pko", "application/vnd.ms-pki.pko" },
        { ".pma", "application/x-perfmon" },
        { ".pmc", "application/x-perfmon" },
        { ".pml", "application/x-perfmon" },
        { ".pmr", "application/x-perfmon" },
        { ".pmw", "application/x-perfmon" },
        { ".png", "image/png" },
        { ".pnm", "image/x-portable-anymap" },
        { ".pnz", "image/png" },
        { ".pot", "application/vnd.ms-powerpoint" },
        { ".potm", "application/vnd.ms-powerpoint.template.macroEnabled.12" },
        { ".potx", "application/vnd.openxmlformats-officedocument.presentationml.template" },
        { ".ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12" },
        { ".ppm", "image/x-portable-pixmap" },
        { ".pps", "application/vnd.ms-powerpoint" },
        { ".ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12" },
        { ".ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow" },
        { ".ppt", "application/vnd.ms-powerpoint" },
        { ".pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12" },
        { ".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
        { ".prf", "application/pics-rules" },
        { ".prm", "application/octet-stream" },
        { ".prx", "application/octet-stream" },
        { ".ps", "application/postscript" },
        { ".psd", "application/octet-stream" },
        { ".psm", "application/octet-stream" },
        { ".psp", "application/octet-stream" },
        { ".pub", "application/x-mspublisher" },
        { ".qt", "video/quicktime" },
        { ".qtl", "application/x-quicktimeplayer" },
        { ".qxd", "application/octet-stream" },
        { ".ra", "audio/x-pn-realaudio" },
        { ".ram", "audio/x-pn-realaudio" },
        { ".rar", "application/octet-stream" },
        { ".ras", "image/x-cmu-raster" },
        { ".rf", "image/vnd.rn-realflash" },
        { ".rgb", "image/x-rgb" },
        { ".rm", "application/vnd.rn-realmedia" },
        { ".rmi", "audio/mid" },
        { ".roff", "application/x-troff" },
        { ".rpm", "audio/x-pn-realaudio-plugin" },
        { ".rtf", "application/rtf" },
        { ".rtx", "text/richtext" },
        { ".scd", "application/x-msschedule" },
        { ".sct", "text/scriptlet" },
        { ".sea", "application/octet-stream" },
        { ".setpay", "application/set-payment-initiation" },
        { ".setreg", "application/set-registration-initiation" },
        { ".sgml", "text/sgml" },
        { ".sh", "application/x-sh" },
        { ".shar", "application/x-shar" },
        { ".sit", "application/x-stuffit" },
        { ".sldm", "application/vnd.ms-powerpoint.slide.macroEnabled.12" },
        { ".sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide" },
        { ".smd", "audio/x-smd" },
        { ".smi", "application/octet-stream" },
        { ".smx", "audio/x-smd" },
        { ".smz", "audio/x-smd" },
        { ".snd", "audio/basic" },
        { ".snp", "application/octet-stream" },
        { ".spc", "application/x-pkcs7-certificates" },
        { ".spl", "application/futuresplash" },
        { ".spx", "audio/ogg" },
        { ".src", "application/x-wais-source" },
        { ".ssm", "application/streamingmedia" },
        { ".sst", "application/vnd.ms-pki.certstore" },
        { ".stl", "application/vnd.ms-pki.stl" },
        { ".sv4cpio", "application/x-sv4cpio" },
        { ".sv4crc", "application/x-sv4crc" },
        { ".svg", "image/svg+xml" },
        { ".svgz", "image/svg+xml" },
        { ".swf", "application/x-shockwave-flash" },
        { ".t", "application/x-troff" },
        { ".tar", "application/x-tar" },
        { ".tcl", "application/x-tcl" },
        { ".tex", "application/x-tex" },
        { ".texi", "application/x-texinfo" },
        { ".texinfo", "application/x-texinfo" },
        { ".tgz", "application/x-compressed" },
        { ".thmx", "application/vnd.ms-officetheme" },
        { ".thn", "application/octet-stream" },
        { ".tif", "image/tiff" },
        { ".tiff", "image/tiff" },
        { ".toc", "application/octet-stream" },
        { ".tr", "application/x-troff" },
        { ".trm", "application/x-msterminal" },
        { ".ts", "video/vnd.dlna.mpeg-tts" },
        { ".tsv", "text/tab-separated-values" },
        { ".ttc", "application/x-font-ttf" },
        { ".ttf", "application/x-font-ttf" },
        { ".tts", "video/vnd.dlna.mpeg-tts" },
        { ".txt", "text/plain" },
        { ".u32", "application/octet-stream" },
        { ".uls", "text/iuls" },
        { ".ustar", "application/x-ustar" },
        { ".vbs", "text/vbscript" },
        { ".vcf", "text/x-vcard" },
        { ".vcs", "text/plain" },
        { ".vdx", "application/vnd.ms-visio.viewer" },
        { ".vml", "text/xml" },
        { ".vsd", "application/vnd.visio" },
        { ".vss", "application/vnd.visio" },
        { ".vst", "application/vnd.visio" },
        { ".vsto", "application/x-ms-vsto" },
        { ".vsw", "application/vnd.visio" },
        { ".vsx", "application/vnd.visio" },
        { ".vtx", "application/vnd.visio" },                
        { ".wasm", "application/wasm" },
        { ".wav", "audio/wav" },
        { ".wax", "audio/x-ms-wax" },
        { ".wbmp", "image/vnd.wap.wbmp" },
        { ".wcm", "application/vnd.ms-works" },
        { ".wdb", "application/vnd.ms-works" },
        { ".webm", "video/webm" },
        { ".webmanifest", "application/manifest+json" }, // https://w3c.github.io/manifest/#media-type-registration
        { ".webp", "image/webp" },
        { ".wks", "application/vnd.ms-works" },
        { ".wm", "video/x-ms-wm" },
        { ".wma", "audio/x-ms-wma" },
        { ".wmd", "application/x-ms-wmd" },
        { ".wmf", "application/x-msmetafile" },
        { ".wml", "text/vnd.wap.wml" },
        { ".wmlc", "application/vnd.wap.wmlc" },
        { ".wmls", "text/vnd.wap.wmlscript" },
        { ".wmlsc", "application/vnd.wap.wmlscriptc" },
        { ".wmp", "video/x-ms-wmp" },
        { ".wmv", "video/x-ms-wmv" },
        { ".wmx", "video/x-ms-wmx" },
        { ".wmz", "application/x-ms-wmz" },
        { ".woff", "application/font-woff" }, // https://www.w3.org/TR/WOFF/#appendix-b
        { ".woff2", "font/woff2" }, // https://www.w3.org/TR/WOFF2/#IMT
        { ".wps", "application/vnd.ms-works" },
        { ".wri", "application/x-mswrite" },
        { ".wrl", "x-world/x-vrml" },
        { ".wrz", "x-world/x-vrml" },
        { ".wsdl", "text/xml" },
        { ".wtv", "video/x-ms-wtv" },
        { ".wvx", "video/x-ms-wvx" },
        { ".x", "application/directx" },
        { ".xaf", "x-world/x-vrml" },
        { ".xaml", "application/xaml+xml" },
        { ".xap", "application/x-silverlight-app" },
        { ".xbap", "application/x-ms-xbap" },
        { ".xbm", "image/x-xbitmap" },
        { ".xdr", "text/plain" },
        { ".xht", "application/xhtml+xml" },
        { ".xhtml", "application/xhtml+xml" },
        { ".xla", "application/vnd.ms-excel" },
        { ".xlam", "application/vnd.ms-excel.addin.macroEnabled.12" },
        { ".xlc", "application/vnd.ms-excel" },
        { ".xlm", "application/vnd.ms-excel" },
        { ".xls", "application/vnd.ms-excel" },
        { ".xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12" },
        { ".xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12" },
        { ".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
        { ".xlt", "application/vnd.ms-excel" },
        { ".xltm", "application/vnd.ms-excel.template.macroEnabled.12" },
        { ".xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template" },
        { ".xlw", "application/vnd.ms-excel" },
        { ".xml", "text/xml" },
        { ".xof", "x-world/x-vrml" },
        { ".xpm", "image/x-xpixmap" },
        { ".xps", "application/vnd.ms-xpsdocument" },
        { ".xsd", "text/xml" },
        { ".xsf", "text/xml" },
        { ".xsl", "text/xml" },
        { ".xslt", "text/xml" },
        { ".xsn", "application/octet-stream" },
        { ".xtp", "application/octet-stream" },
        { ".xwd", "image/x-xwindowdump" },
        { ".z", "application/x-compress" },
        { ".zip", "application/x-zip-compressed" },
    })
{
}
#endregion

/// <summary>
/// Creates a lookup engine using the provided mapping.
/// It is recommended that the IDictionary instance use StringComparer.OrdinalIgnoreCase.
/// </summary>
/// <param name="mapping"></param>
public FileExtensionContentTypeProvider(IDictionary<string, string> mapping)
{
    if (mapping == null)
    {
        throw new ArgumentNullException(nameof(mapping));
    }
    Mappings = mapping;
}

/// <summary>
/// The cross reference table of file extensions and content-types.
/// </summary>
public IDictionary<string, string> Mappings { get; private set; }

2. StaticFiles 中间件 源码分析

namespace Microsoft.AspNetCore.Builder
{
    /// <summary>
    /// Extension methods for the StaticFileMiddleware
    /// 静态文件处理的中间件具体处理是在StaticFileMiddleware
    /// </summary>
    public static class StaticFileExtensions
    {
        /// <summary>
        /// Enables static file serving for the current request path
        /// </summary>
        /// <param name="app"></param>
        /// <returns></returns>
        public static IApplicationBuilder UseStaticFiles(this IApplicationBuilder app)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }

            return app.UseMiddleware<StaticFileMiddleware>();
        }

        /// <summary>
        /// Enables static file serving for the given request path
        /// </summary>
        /// <param name="app"></param>
        /// <param name="requestPath">The relative request path.</param>
        /// <returns></returns>
        public static IApplicationBuilder UseStaticFiles(this IApplicationBuilder app, string requestPath)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }

            return app.UseStaticFiles(new StaticFileOptions
            {
                RequestPath = new PathString(requestPath)
            });
        }

        /// <summary>
        /// Enables static file serving with the given options
        /// </summary>
        /// <param name="app"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IApplicationBuilder UseStaticFiles(this IApplicationBuilder app, StaticFileOptions options)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }
            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            return app.UseMiddleware<StaticFileMiddleware>(Options.Create(options));
        }
    }
}

public class StaticFileMiddleware
{
    private readonly StaticFileOptions _options;
    private readonly PathString _matchUrl;
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;
    private readonly IFileProvider _fileProvider;
    private readonly IContentTypeProvider _contentTypeProvider;

    /// <summary>
    /// Creates a new instance of the StaticFileMiddleware.
    /// </summary>
    /// <param name="next">The next middleware in the pipeline.</param>
    /// <param name="hostingEnv">The <see cref="IWebHostEnvironment"/> used by this middleware.</param>
    /// <param name="options">The configuration options.</param>
    /// <param name="loggerFactory">An <see cref="ILoggerFactory"/> instance used to create loggers.</param>
    public StaticFileMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, IOptions<StaticFileOptions> options, ILoggerFactory loggerFactory)
    {
        //去除参数校验
        _next = next;
        _options = options.Value;
        _contentTypeProvider = _options.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
        _fileProvider = _options.FileProvider ?? Helpers.ResolveFileProvider(hostingEnv);
        _matchUrl = _options.RequestPath;
        _logger = loggerFactory.CreateLogger<StaticFileMiddleware>();
    }

    /// <summary>
    /// Processes a request to determine if it matches a known file, and if so, serves it.
    /// </summary>
    /// <param name="context"></param>
    /// <returns></returns>
    public Task Invoke(HttpContext context)
    {
        //去除一些验证
        return TryServeStaticFile(context, contentType, subPath);
    }

    private Task TryServeStaticFile(HttpContext context, string contentType, PathString subPath)
    {
        //通过StaticFileContext进行静态文件处理
        var fileContext = new StaticFileContext(context, _options, _logger, _fileProvider, contentType, subPath);

        if (!fileContext.LookupFileInfo())
        {
            _logger.FileNotFound(fileContext.SubPath);
        }
        else
        {
            // If we get here, we can try to serve the file
            return fileContext.ServeStaticFile(context, _next);
        }

        return _next(context);
    }
}

internal struct StaticFileContext
{
    private const int StreamCopyBufferSize = 64 * 1024;

    private readonly HttpContext _context;
    private readonly StaticFileOptions _options;
    private readonly HttpRequest _request;
    private readonly HttpResponse _response;
    private readonly ILogger _logger;
    private readonly IFileProvider _fileProvider;
    private readonly string _method;
    private readonly string _contentType;

    private IFileInfo _fileInfo;
    private EntityTagHeaderValue _etag;
    private RequestHeaders _requestHeaders;
    private ResponseHeaders _responseHeaders;
    private RangeItemHeaderValue _range;

    private long _length;
    private readonly PathString _subPath;
    private DateTimeOffset _lastModified;

    private PreconditionState _ifMatchState;
    private PreconditionState _ifNoneMatchState;
    private PreconditionState _ifModifiedSinceState;
    private PreconditionState _ifUnmodifiedSinceState;

    private RequestType _requestType;

    public StaticFileContext(HttpContext context, StaticFileOptions options, ILogger logger, IFileProvider fileProvider, string contentType, PathString subPath)
    {
        _context = context;
        _options = options;
        _request = context.Request;
        _response = context.Response;
        _logger = logger;
        _fileProvider = fileProvider;
        _method = _request.Method;
        _contentType = contentType;
        _fileInfo = null;
        _etag = null;
        _requestHeaders = null;
        _responseHeaders = null;
        _range = null;

        _length = 0;
        _subPath = subPath;
        _lastModified = new DateTimeOffset();
        _ifMatchState = PreconditionState.Unspecified;
        _ifNoneMatchState = PreconditionState.Unspecified;
        _ifModifiedSinceState = PreconditionState.Unspecified;
        _ifUnmodifiedSinceState = PreconditionState.Unspecified;

        if (HttpMethods.IsGet(_method))
        {
            _requestType = RequestType.IsGet;
        }
        else if (HttpMethods.IsHead(_method))
        {
            _requestType = RequestType.IsHead;
        }
        else
        {
            _requestType = RequestType.Unspecified;
        }
    }

    public async Task ServeStaticFile(HttpContext context, RequestDelegate next)
    {
        ComprehendRequestHeaders();
        switch (GetPreconditionState())
        {
            case PreconditionState.Unspecified:
            case PreconditionState.ShouldProcess:
                if (IsHeadMethod)
                {
                    await SendStatusAsync(StatusCodes.Status200OK);
                    return;
                }

                try
                {
                    if (IsRangeRequest)
                    {
                        await SendRangeAsync();
                        return;
                    }

                    await SendAsync();  //将文件进行响应
                    _logger.FileServed(SubPath, PhysicalPath);
                    return;
                }
                catch (FileNotFoundException)
                {
                    context.Response.Clear();
                }
                await next(context);
                return;
            case PreconditionState.NotModified:
                _logger.FileNotModified(SubPath);
                await SendStatusAsync(StatusCodes.Status304NotModified);
                return;
            case PreconditionState.PreconditionFailed:
                _logger.PreconditionFailed(SubPath);
                await SendStatusAsync(StatusCodes.Status412PreconditionFailed);
                return;
            default:
                var exception = new NotImplementedException(GetPreconditionState().ToString());
                Debug.Fail(exception.ToString());
                throw exception;
        }
    }

    public async Task SendAsync()
    {
        SetCompressionMode();
        ApplyResponseHeaders(StatusCodes.Status200OK);
        string physicalPath = _fileInfo.PhysicalPath;
        var sendFile = _context.Features.Get<IHttpResponseBodyFeature>();
        if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
        {
            // We don't need to directly cancel this, if the client disconnects it will fail silently.
            await sendFile.SendFileAsync(physicalPath, 0, _length, CancellationToken.None);
            return;
        }

        try
        {
            using (var readStream = _fileInfo.CreateReadStream())
            {
                // Larger StreamCopyBufferSize is required because in case of FileStream readStream isn't going to be buffering
                await StreamCopyOperation.CopyToAsync(readStream, _response.Body, _length, StreamCopyBufferSize, _context.RequestAborted);
            }
        }
        catch (OperationCanceledException ex)
        {
            _logger.WriteCancelled(ex);
            // Don't throw this exception, it's most likely caused by the client disconnecting.
            // However, if it was cancelled for any other reason we need to prevent empty responses.
            _context.Abort();
        }
    }
}