/// <summary>
/// Sets the cache headers for static files.
/// </summary>
/// <param name="context">The static file response context to set the headers for.</param>
private void SetCacheHeaders(StaticFileResponseContext context)
{
var maxAge = TimeSpan.FromDays(7);
if (context.File.Exists && HostingEnvironment.IsProduction())
{
string?extension = Path.GetExtension(context.File.PhysicalPath);
// These files are served with a content hash in the URL so can be cached for longer
bool isScriptOrStyle =
string.Equals(extension, ".css", StringComparison.OrdinalIgnoreCase) ||
string.Equals(extension, ".js", StringComparison.OrdinalIgnoreCase);
if (isScriptOrStyle)
{
maxAge = TimeSpan.FromDays(365);
}
}
var headers = context.Context.Response.GetTypedHeaders();
headers.CacheControl = new CacheControlHeaderValue()
{
MaxAge = maxAge,
};
}
private static void SetCacheControlHeader(StaticFileResponseContext context)
{
const int durationInSeconds = 60 * 60 * 24;
context.Context.Response.Headers[HeaderNames.CacheControl] =
"public,max-age=" + durationInSeconds;
}
private void OnPrepareResponse(StaticFileResponseContext context)
{
bool setCachingHeaders = false;
switch (_staticFilesSettings.CacheMode)
{
case StaticFileCacheMode.None:
return;
case StaticFileCacheMode.All:
setCachingHeaders = true;
break;
case StaticFileCacheMode.OnlyVersionedFiles:
// only cache resources that use the asp-append-version parameter convention
setCachingHeaders = !string.IsNullOrEmpty(context.Context.Request.Query["v"]);
break;
default:
throw new InvalidOperationException("StaticFileCacheMode not regonised: " + _staticFilesSettings.CacheMode);
}
if (!setCachingHeaders)
{
return;
}
// cache for 1 year
context.Context.Response.Headers[HeaderNames.CacheControl] = new[] { "public,max-age=" + _staticFilesSettings.MaxAge };
}
private static void OnPrepareResponse(StaticFileResponseContext context)
{
var file = context.File;
var request = context.Context.Request;
var response = context.Context.Response;
if (file.Name.EndsWith(".gz"))
{
response.Headers[HeaderNames.ContentEncoding] = "gzip";
return;
}
var acceptEncoding = (string)request.Headers[HeaderNames.AcceptEncoding];
if (acceptEncoding.IndexOf("gzip", StringComparison.OrdinalIgnoreCase) == -1)
{
return;
}
if (!File.Exists(file.PhysicalPath + ".gz"))
{
return;
}
response.StatusCode = (int)HttpStatusCode.MovedPermanently;
response.Headers[HeaderNames.Location] = request.Path.Value + ".gz";
}
private static void CacheStaticContent(StaticFileResponseContext ctx)
{
const int durationInSeconds = 60 * 60 * 24 * 365;
ctx.Context.Response.Headers[Microsoft.Net.Http.Headers.HeaderNames.CacheControl] =
"public,max-age=" + durationInSeconds;
}
/// <summary>
/// 设置cache control
/// </summary>
/// <param name="context"></param>
public static void SetCacheControl(StaticFileResponseContext context)
{
int second = 365 * 24 * 60 * 60;
context.Context.Response.Headers.Add("Cache-Control", new[] { "public,max-age=" + second });
context.Context.Response.Headers.Add("Expires", new[] { DateTime.UtcNow.AddYears(1).ToString("R") }); // Format RFC1123
}
private static void NoCacheOnIndex(StaticFileResponseContext context)
{
if (context.File.Name == "index.html")
{
context.Context.Response.Headers.Add("Cache-Control", new[] { "no-cache", "no-store", "must-revalidate" });
context.Context.Response.Headers.Add("Pragma", new[] { "no-cache" });
context.Context.Response.Headers.Add("Expires", new[] { "0" });
}
}
private void PrepareStaticFileResponse(StaticFileResponseContext context)
{
var headers = context.Context.Response.Headers;
headers
.Add("cache-control", "private,max-age=31536000,immutable");
headers
.Add("x-content-type-options", "nosniff");
}
private static void ConfigureCacheControl(StaticFileResponseContext ctx)
{
if (ctx.File.Name.EndsWith(".clr", StringComparison.OrdinalIgnoreCase))
{
// Cache managed files for a year, based on this update:
// https://github.com/nventive/Uno.Wasm.Bootstrap/commit/f4859452c715c54ac40b968a303a242b0399d59a
ctx.Context.Response.Headers.Append("Cache-Control", "public,max-age=31536000");
}
}
void staticFileResponse(StaticFileResponseContext context)
{
var commonSettings = EngineContext.Current.Resolve <CommonSettings>();
if (!string.IsNullOrEmpty(commonSettings.StaticFilesCacheControl))
{
context.Context.Response.Headers.Append(HeaderNames.CacheControl, commonSettings.StaticFilesCacheControl);
}
}
private static void PrepareResponse(StaticFileResponseContext context)
{
bool flag = LoggerExtensions.ContentTypes.Contains(context.Context.Response.ContentType);
if (flag)
{
HttpResponse response = context.Context.Response;
response.ContentType += "; charset=utf-8";
}
}
private static StaticFileResponseContext ResponseContext()
{
var context = new StaticFileResponseContext(new DefaultHttpContext(),
file: new FakeFileInfo());
//var type = context.GetType();
//var property = type.GetProperty(nameof(context.Context));
//property!.SetValue(context, new DefaultHttpContext(), null);
return(context);
}
private static void SetCacheHeaders(StaticFileResponseContext ctx)
{
var typedHeaders = ctx.Context.Response.GetTypedHeaders();
if (typedHeaders.CacheControl != null)
{
return;
}
typedHeaders.CacheControl = new CacheControlHeaderValue {
NoCache = true
};
}
/// <summary>
///
/// </summary>
/// <param name="staticFileResponseContext"></param>
public static void OnPrepareResponse(StaticFileResponseContext staticFileResponseContext)
{
if (staticFileResponseContext == null ||
staticFileResponseContext.File == null ||
(!".nuspec".Equals(Path.GetExtension(staticFileResponseContext.File.Name), StringComparison.OrdinalIgnoreCase) && !".nupkg".Equals(Path.GetExtension(staticFileResponseContext.File.Name), StringComparison.OrdinalIgnoreCase)))
{
return;
}
var nuGetPackageIndex = staticFileResponseContext.Context.RequestServices.GetService <INuGetPackageIndex>();
nuGetPackageIndex.IncrementDownloadCounter(staticFileResponseContext.File.PhysicalPath);
}
static void staticFileResponse(StaticFileResponseContext context)
{
if (!DataSettingsManager.DatabaseIsInstalled)
{
return;
}
var commonSettings = EngineContext.Current.Resolve <CommonSettings>();
if (!string.IsNullOrEmpty(commonSettings.StaticFilesCacheControl))
{
context.Context.Response.Headers.Append(HeaderNames.CacheControl, commonSettings.StaticFilesCacheControl);
}
}
private void AddFileCacheHeaders(StaticFileResponseContext context)
{
// If we see you have sha on the url we send aggresive cache values
// otherwise we tell to not cache ever
if (context.Context.Request.Query.ContainsKey(Constants.FileUrlShaKey))
{
// Cache for a year
context.Context.Response.Headers["Cache-Control"] = "public, max-age=31536000";
}
else
{
context.Context.Response.Headers["Cache-Control"] = "no-cache";
context.Context.Response.Headers["Pragma"] = "no-cache";
context.Context.Response.Headers["Expires"] = "Thu, 01 Jan 1970 00:00:00 GMT";
}
}
private static void SetCacheHeaders(StaticFileResponseContext ctx)
{
// By setting "Cache-Control: no-cache", we're allowing the browser to store
// a cached copy of the response, but telling it that it must check with the
// server for modifications (based on Etag) before using that cached copy.
// Longer term, we should generate URLs based on content hashes (at least
// for published apps) so that the browser doesn't need to make any requests
// for unchanged files.
var headers = ctx.Context.Response.GetTypedHeaders();
if (headers.CacheControl == null)
{
headers.CacheControl = new CacheControlHeaderValue
{
NoCache = true
};
}
}
public bool CanCache(StaticFileResponseContext context)
{
//Static
if (!_config.UseCacheStatic)
{
return(false);
}
string path = context.Context.Request.Path;
if (!this.IsPathStatic(path))
{
return(false);
}
string queryString = context.Context.Request.QueryString.ToString();
return(queryString.Contains("ab=" + _config.ApplicationBuild));
}
static void OnPrepareStaticFileResponse(StaticFileResponseContext staticFileContext)
{
var context = staticFileContext.Context;
var req = context.Request;
var res = context.Response;
var headers = res.Headers;
if (req.Query.ContainsKey("DX_HTTP_CACHE"))
{
headers["Cache-Control"] = "public, max-age=31536000";
}
else
{
headers["Cache-Control"] = "private, must-revalidate, max-age=0";
}
headers.Remove("ETag");
}
private static void GZipStaticContent(StaticFileResponseContext ctx)
{
var headers = ctx.Context.Response.Headers;
var contentType = headers["Content-Type"];
if (contentType != "application/x-gzip" && !ctx.File.Name.EndsWith(".gz"))
{
return;
}
var fileNameToTry = ctx.File.Name.Substring(0, ctx.File.Name.Length - 3);
if (new FileExtensionContentTypeProvider().TryGetContentType(fileNameToTry, out var mimeType))
{
headers.Add("Content-Encoding", "gzip");
headers["Content-Type"] = mimeType;
}
}
public void Prepare(IContentTypeProvider contentTypeProvider, StaticFileResponseContext staticFileResponseContext)
{
foreach (var compressionType in CompressedAlternativeFileProvider.CompressionTypes.Keys)
{
var fileExtension = CompressedAlternativeFileProvider.CompressionTypes[compressionType];
if (staticFileResponseContext.File.Name.EndsWith(fileExtension, StringComparison.OrdinalIgnoreCase))
{
// we need to restore the original content type, otherwise it would be based on the compression type
// (for example "application/brotli" instead of "text/html")
if (contentTypeProvider.TryGetContentType(staticFileResponseContext.File.PhysicalPath.Remove(
staticFileResponseContext.File.PhysicalPath.Length - fileExtension.Length, fileExtension.Length), out var contentType))
{
staticFileResponseContext.Context.Response.ContentType = contentType;
}
staticFileResponseContext.Context.Response.Headers.Add("Content-Encoding", new[] { compressionType });
}
}
}
// https://gunnarpeipman.com/aspnet-core-precompressed-files/
public static void ServeGzipFiles(this StaticFileResponseContext context)
{
var headers = context.Context.Response.Headers;
var contentType = headers["Content-Type"];
if (contentType != "application/x-gzip" && !context.File.Name.EndsWith(".gz"))
{
return;
}
var fileNameToTry = context.File.Name.Substring(0, context.File.Name.Length - 3);
if (_fileTypes.TryGetContentType(fileNameToTry, out var mimeType))
{
headers.Add("Content-Encoding", "gzip");
headers["Content-Type"] = mimeType;
}
}
/// <summary>
/// without this the browser did not seem to understand the gzipped file
/// </summary>
/// <param name="context"></param>
public static void OnPrepareResponse(StaticFileResponseContext context)
{
var file = context.File;
var response = context.Context.Response;
if (file.Name.EndsWith(".gz"))
{
response.Headers[HeaderNames.ContentEncoding] = "gzip";
if (file.Name.EndsWith(".css.gz"))
{
response.Headers[HeaderNames.ContentType] = "text/css";
}
if (file.Name.EndsWith(".js.gz"))
{
response.Headers[HeaderNames.ContentType] = "application/javascript";
}
return;
}
}
private void OnPrepareResponse(StaticFileResponseContext context)
{
context.Context.Response.Headers.Add("Cache-Control", new[] { "public,max-age=31536000" });
}
public void Prepare(IContentTypeProvider contentTypeProvider, StaticFileResponseContext staticFileResponseContext)
{
}
public static void CacheFiles(this StaticFileResponseContext ctx)
{
ctx.Context.Response.Headers.Append("Cache-Control", "public,max-age=2592000");
ctx.Context.Response.Headers.Append("Expires", DateTime.UtcNow.AddDays(30).ToString("R", CultureInfo.InvariantCulture));
}
static void preventCaching(StaticFileResponseContext http)
{
http.Context.Response.Headers.Add("Cache-Control", "no-cache, no-store");
http.Context.Response.Headers.Add("Expires", "-1");
}
