强制浏览器在asp.net应用程序中获取最新的js和css文件

某些浏览器会缓存js和css文件，除非您强制将它们刷新，否则无法刷新它们。最简单的方法是什么。

我刚刚实施了似乎可行的解决方案。

在页面上声明一个版本变量

  public string version { get; set; }

从web.config密钥获取版本号

 version = ConfigurationManager.AppSettings["versionNumber"];

在您的aspx页面中，像这样调用javascript和样式表

<script src="scripts/myjavascript.js?v=<%=version %>" type="text/javascript"></script>
<link href="styles/mystyle.css?v=<%=version %>" rel="stylesheet" type="text/css" />

因此，如果您在web.config中将1.0的版本设置为1.1，则浏览器将下载最新文件，这有望为您和您的用户省去一些麻烦。

是否有另一种更好的解决方案，还是会导致网站出现无法预料的问题？

我通过添加最后修改的时间戳作为脚本的查询参数来解决此问题。

我使用扩展方法进行了此操作，并在CSHTML文件中使用了它。 注意：此实现将时间戳缓存1分钟，因此我们不会对磁盘​​造成太大的影响。

这是扩展方法：

public static class JavascriptExtension {
    public static MvcHtmlString IncludeVersionedJs(this HtmlHelper helper, string filename) {
        string version = GetVersion(helper, filename);
        return MvcHtmlString.Create("<script type='text/javascript' src='" + filename + version + "'></script>");
    }

    private static string GetVersion(this HtmlHelper helper, string filename)
    {
        var context = helper.ViewContext.RequestContext.HttpContext;

        if (context.Cache[filename] == null)
        {
            var physicalPath = context.Server.MapPath(filename);
            var version = $"?v={new System.IO.FileInfo(physicalPath).LastWriteTime.ToString("MMddHHmmss")}";
            context.Cache.Add(filename, version, null,
              DateTime.Now.AddMinutes(5), TimeSpan.Zero,
              CacheItemPriority.Normal, null);
            return version;
        }
        else
        {
            return context.Cache[filename] as string;
        }
    }
}

然后在CSHTML页面中：

 @Html.IncludeVersionedJs("/MyJavascriptFile.js")

在呈现的HTML中，这显示为：

 <script type='text/javascript' src='/MyJavascriptFile.js?20111129120000'></script>

您的解决方案有效。实际上，它非常受欢迎。

甚至堆栈溢出也使用类似的方法：

<link rel="stylesheet" href="http://sstatic.net/so/all.css?v=6184"> 

v=6184SVN版本号可能在哪里。

在ASP.NET Core（MVC 6）中，这可以通过asp-append-version标记帮助器立即使用：

<script src="scripts/myjavascript.js" asp-append-version="true"></script>
<link href="styles/mystyle.css rel="stylesheet" asp-append-version="true" />

如果您对JS / CSS使用捆绑软件，则ASP.NET MVC将为您解决这一问题。它将以GUID的形式自动将版本号附加到您的捆绑软件中，并且仅在捆绑软件更新时更新该GUID（aka任何源文件都有更改）。

如果您有大量的JS / CSS文件，这也会有所帮助，因为它可以大大缩短内容加载时间！

看这里

在asp.net中有一个内置方法：bundled。只需使用它。每个新版本都有唯一的后缀“？v = XXXXXXX”。在调试模式下，捆绑处于关闭状态，以便在web.config中打开make设置：

<system.web>
    <compilation debug="false" />
</system.web>

或添加到方法RegisterBundles（BundleCollection bundles）：

BundleTable.EnableOptimizations = true;

例如：

BundleConfig.cs：

bundles.Add(new ScriptBundle("~/Scripts/myjavascript.js")
                .Include("~/Scripts/myjavascript.js"));

bundles.Add(new StyleBundle("~/Content/mystyle.css")
                .Include("~/Content/mystyle.css"));

_Layout.cshtml：

@Scripts.Render("~/Scripts/myjavascript.js")
@Styles.Render("~/Content/mystyle.css")

这个问题的答案比操作中操作员给出的答案更简单（方法相同）：

在web.config中定义密钥：

<add key="VersionNumber" value="06032014"/>

直接从aspx页面调用appsettings：

<link href="styles/navigation.css?v=<%=ConfigurationManager.AppSettings["VersionNumber"]%>" rel="stylesheet" type="text/css" />

基于Adam Tegan的答案，进行了修改以用于Web窗体应用程序。

在.cs类代码中：

public static class FileUtility
{
    public static string SetJsVersion(HttpContext context, string filename) {
        string version = GetJsFileVersion(context, filename);
        return filename + version;
    }

    private static string GetJsFileVersion(HttpContext context, string filename)
    {
        if (context.Cache[filename] == null)
        {
            string filePhysicalPath = context.Server.MapPath(filename);

            string version = "?v=" + GetFileLastModifiedDateTime(context, filePhysicalPath, "yyyyMMddhhmmss");

            return version;
        }
        else
        {
            return string.Empty;
        }
    }

    public static string GetFileLastModifiedDateTime(HttpContext context, string filePath, string dateFormat)
    {
        return new System.IO.FileInfo(filePath).LastWriteTime.ToString(dateFormat);
    }
}

在aspx标记中：

<script type="text/javascript" src='<%= FileUtility.SetJsVersion(Context,"/js/exampleJavaScriptFile.js") %>'></script>

在呈现的HTML中，它显示为

<script type="text/javascript" src='/js/exampleJavaScriptFile.js?v=20150402021544'></script>

有趣的是，即使它应该是故障安全的，该站点也存在与您描述的一些代理设置有关的方法问题。

查看此元堆栈溢出讨论。

因此，鉴于此，可能不使用GET参数进行更新，而是使用实际的文件名：

href="/css/scriptname/versionNumber.css" 

即使要做更多的工作，您也必须实际创建文件或为其构建URL重写。

我想要一个简单的衬板，使该路径成为破坏缓存的唯一路径。这对我有用：

<script src="scripts/main.js?bust_js_cache=<%=System.IO.File.GetLastWriteTime(Server.MapPath("scripts/main.js")).ToString("HH:mm:ss")%>" type="text/javascript"></script>

如果文件自上次加载到页面以来已被修改，浏览器将提取更新的文件。

它last modified从.js文件生成戳记，然后将其夹在其中，而不是可能不容易获得访问的版本。

<script src="scripts/main.js?bust_js_cache=10:18:38" type="text/javascript"></script>

另一种选择是获取文件的校验和。

这是与ASP.NET 5 / MVC 6 / vNext一起使用的方法。

步骤1：创建一个类，以返回文件的上次写入时间，类似于该线程中的其他答案。请注意，这需要ASP.NET 5（或其他）依赖项注入。

public class FileVersionService
{
    private IHostingEnvironment _hostingEnvironment;
    public FileVersionService(IHostingEnvironment hostingEnvironment)
    {
        _hostingEnvironment = hostingEnvironment;
    }

    public string GetFileVersion(string filename)
    {
       var path = string.Format("{0}{1}", _hostingEnvironment.WebRootPath, filename);
       var fileInfo = new FileInfo(path);
       var version = fileInfo.LastWriteTimeUtc.ToString("yyyyMMddhhmmssfff");
       return version;
     }
}

步骤2：将要注入的服务注册到startup.cs中：

public void ConfigureServices(IServiceCollection services)
{
    ...
    services.AddScoped<FileVersionService>();
    ...
}

步骤3：然后，在ASP.NET 5中，可以将服务直接注入到诸如_Layout.cshtml之类的布局视图中，如下所示：

@inject Namespace.Here.FileVersionService fileVersionService
<!DOCTYPE html>
<html lang="en" class="@ViewBag.HtmlClass">
<head>
    ...
    <link href="/css/styles.css?v=@fileVersionService.GetFileVersion("\\css\\styles.css")" rel="stylesheet" />
    ...
</head>
<body>
    ...
</body>

可以完成一些整理工作，以更好地组合物理路径并以与语法更一致的样式来处理文件名，但这是一个起点。希望它能帮助人们迁移到ASP.NET 5。

我在aspnet MVC 4网站中采用了稍微不同的技术：

_ViewStart.cshtml：

@using System.Web.Caching
@using System.Web.Hosting
@{
    Layout = "~/Views/Shared/_Layout.cshtml";
    PageData.Add("scriptFormat", string.Format("<script src=\"{{0}}?_={0}\"></script>", GetDeployTicks()));
}

@functions
{

    private static string GetDeployTicks()
    {
        const string cacheKey = "DeployTicks";
        var returnValue = HttpRuntime.Cache[cacheKey] as string;
        if (null == returnValue)
        {
            var absolute = HostingEnvironment.MapPath("~/Web.config");
            returnValue = File.GetLastWriteTime(absolute).Ticks.ToString();
            HttpRuntime.Cache.Insert(cacheKey, returnValue, new CacheDependency(absolute));
        }
        return returnValue;
    }
}

然后在实际视图中：

 @Scripts.RenderFormat(PageData["scriptFormat"], "~/Scripts/Search/javascriptFile.min.js")

<?php $rand_no = rand(10000000, 99999999)?> <script src="scripts/myjavascript.js?v=<?=$rand_no"></script>

这适用于所有浏览器。在这里，我使用PHP生成随机数。您可以使用自己的服务器端语言。

从上面的答案开始，我修改了一些代码以使帮助程序也能与CSS文件一起使用，并且每次在文件中进行某些更改时（不仅是在构建时）都添加一个版本

public static class HtmlHelperExtensions
{
    public static MvcHtmlString IncludeVersionedJs(this HtmlHelper helper, string filename)
    {
        string version = GetVersion(helper, filename);
        return MvcHtmlString.Create("<script type='text/javascript' src='" + filename + version + "'></script>");
    }

    public static MvcHtmlString IncludeVersionedCss(this HtmlHelper helper, string filename)
    {
        string version = GetVersion(helper, filename);
        return MvcHtmlString.Create("<link href='" + filename + version + "' type ='text/css' rel='stylesheet'/>");
    }

    private static string GetVersion(this HtmlHelper helper, string filename)
    {
        var context = helper.ViewContext.RequestContext.HttpContext;
        var physicalPath = context.Server.MapPath(filename);
        var version = "?v=" +
        new System.IO.FileInfo(physicalPath).LastWriteTime
        .ToString("yyyyMMddHHmmss");
        context.Cache.Add(physicalPath, version, null,
          DateTime.Now.AddMinutes(1), TimeSpan.Zero,
          CacheItemPriority.Normal, null);

        if (context.Cache[filename] == null)
        {
            context.Cache[filename] = version;
            return version;
        }
        else
        {
            if (version != context.Cache[filename].ToString())
            {
                context.Cache[filename] = version;
                return version;
            }
            return context.Cache[filename] as string;
        }
    }
}

获取文件修改时间，如下图

private static string GetLastWriteTimeForFile(string pathVal)
    {
        return System.IO.File.GetLastWriteTime(HostingEnvironment.MapPath(pathVal)).ToFileTime().ToString();
    }

将此附加为查询字符串

public static string AppendDateInFile(string pathVal)
    {
        var patheWithDate = new StringBuilder(pathVal);
        patheWithDate.AppendFormat("{0}x={1}",
                               pathVal.IndexOf('?') >= 0 ? '&' : '?',
                               GetLastWriteTimeForFile(pathVal));
        return patheWithDate.ToString();
    }

从标记中调用它。

MVC扩展助手方法

添加扩展方法

namespace TNS.Portal.Helpers
{
    public static class ScriptExtensions
    {
        public static HtmlString QueryStringScript<T>(this HtmlHelper<T> html, string path)
        {
            var file = html.ViewContext.HttpContext.Server.MapPath(path);
            DateTime lastModified = File.GetLastWriteTime(file);
            TagBuilder builder = new TagBuilder("script");
            builder.Attributes["src"] = path + "?modified=" + lastModified.ToString("yyyyMMddhhmmss");
            return new HtmlString(builder.ToString());
        }

       public static HtmlString QueryStringStylesheet<T>(this HtmlHelper<T> html, string path)
       {
        var file = html.ViewContext.HttpContext.Server.MapPath(path);
        DateTime lastModified = File.GetLastWriteTime(file);
        TagBuilder builder = new TagBuilder("link");
        builder.Attributes["href"] = path + "?modified=" + lastModified.ToString("yyyyMMddhhmmss");
        builder.Attributes["rel"] = "stylesheet";
        return new HtmlString(builder.ToString());
      }

    }
}

在web.config中添加此名称空间

<system.web.webPages.razor>
    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
    <pages pageBaseType="System.Web.Mvc.WebViewPage">
      <namespaces>
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Optimization"/>
        <add namespace="System.Web.Routing" />
        <add namespace="TNS.Portal" />
        <add namespace="TNS.Portal.Helpers" />
      </namespaces>
    </pages>
  </system.web.webPages.razor>

在视图中使用它

@Html.QueryStringScript("/Scripts/NPIAjaxCalls.js")
@Html.QueryStringStylesheet("/Content/StyledRadio.css")

简化的先前建议，并为.NET Web Forms开发人员提供了代码。

这将在资源的文件路径中接受相对（“〜/”）和绝对URL。

放入一个静态扩展类文件，如下：

public static string VersionedContent(this HttpContext httpContext, string virtualFilePath)
{
    var physicalFilePath = httpContext.Server.MapPath(virtualFilePath);
    if (httpContext.Cache[physicalFilePath] == null)
    {
        httpContext.Cache[physicalFilePath] = ((Page)httpContext.CurrentHandler).ResolveUrl(virtualFilePath) + (virtualFilePath.Contains("?") ? "&" : "?") + "v=" + File.GetLastWriteTime(physicalFilePath).ToString("yyyyMMddHHmmss");
    }
    return (string)httpContext.Cache[physicalFilePath];
}

然后像这样在母版页中调用它：

<link type="text/css" rel="stylesheet" href="<%= Context.VersionedContent("~/styles/mystyle.css") %>" />
<script type="text/javascript" src="<%= Context.VersionedContent("~/scripts/myjavascript.js") %>"></script>

基于以上答案，我编写了一个小的扩展类来处理CSS和JS文件：

public static class TimestampedContentExtensions
{
    public static string VersionedContent(this UrlHelper helper, string contentPath)
    {
        var context = helper.RequestContext.HttpContext;

        if (context.Cache[contentPath] == null)
        {
            var physicalPath = context.Server.MapPath(contentPath);
            var version = @"v=" + new FileInfo(physicalPath).LastWriteTime.ToString(@"yyyyMMddHHmmss");

            var translatedContentPath = helper.Content(contentPath);

            var versionedContentPath =
                contentPath.Contains(@"?")
                    ? translatedContentPath + @"&" + version
                    : translatedContentPath + @"?" + version;

            context.Cache.Add(physicalPath, version, null, DateTime.Now.AddMinutes(1), TimeSpan.Zero,
                CacheItemPriority.Normal, null);

            context.Cache[contentPath] = versionedContentPath;
            return versionedContentPath;
        }
        else
        {
            return context.Cache[contentPath] as string;
        }
    }
}

而不是这样写：

<link href="@Url.Content(@"~/Content/bootstrap.min.css")" rel="stylesheet" type="text/css" />
<script src="@Url.Content(@"~/Scripts/bootstrap.min.js")"></script>

您现在可以编写：

<link href="@Url.VersionedContent(@"~/Content/bootstrap.min.css")" rel="stylesheet" type="text/css" />
<script src="@Url.VersionedContent(@"~/Scripts/bootstrap.min.js")"></script>

即简单地替换Url.Content为Url.VersionedContent。

生成的URL类似于：

<link href="/Content/bootstrap.min.css?v=20151104105858" rel="stylesheet" type="text/css" />
<script src="/Scripts/bootstrap.min.js?v=20151029213517"></script>

如果使用扩展类，则可能要添加错误处理，以防MapPath调用不起作用，因为contentPath它不是物理文件。

我使用类似的方法来做您正在做的事情，而无需修改每个页面。添加了一个PreRender事件是主文件。它把我的逻辑放在一个地方，并且适用于js和css文件。

protected void Page_PreRender(object sender, EventArgs e)
    {
        HtmlLink link = null;
        LiteralControl script = null;


        foreach (Control c in Header.Controls)
        {
            //StyleSheet add version
            if (c is HtmlLink)
            {
                link = c as HtmlLink;


                if (link.Href.EndsWith(".css", StringComparison.InvariantCultureIgnoreCase))
                {
                    link.Href += string.Format("?v={0}", ConfigurationManager.AppSettings["agVersion"]);
                }

            }

            //Js add version
            if (c is LiteralControl)
            {
                script = c as LiteralControl;

                if (script.Text.Contains(".js"))
                {
                    var foundIndexes = new List<int>();


                    for (int i = script.Text.IndexOf(".js\""); i > -1; i = script.Text.IndexOf(".js\"", i + 1))
                    {

                        foundIndexes.Add(i);
                    }

                    for (int i = foundIndexes.Count - 1; i >= 0; i--)
                    {

                        script.Text = script.Text.Insert(foundIndexes[i] + 3, string.Format("?v={0}", ConfigurationManager.AppSettings["agVersion"]));
                    }
                }

            }

        }
    }

您可以覆盖脚本或样式的DefaultTagFormat属性。

Scripts.DefaultTagFormat = @"<script src=""{0}?v=" + ConfigurationManager.AppSettings["pubversion"] + @"""></script>";
Styles.DefaultTagFormat = @"<link href=""{0}?v=" + ConfigurationManager.AppSettings["pubversion"] + @""" rel=""stylesheet""/>";

为了在ASP.Net Ajax应用程序中解决此问题，我创建了一个扩展，然后在母版页中调用。

有关更多详细信息，您可以通过链接。

通过以下概念在.net应用程序中实现CSS版本控制的简便方法：无需编写后端代码。

<link href="<%="../../App_Themes/Base/css/main.css?v="+ DateTime.Now.ToString("yyyyMMddhhmmss") +""%>" rel="stylesheet" />

这样做的主要问题主要是，每次对CSS或JS文件进行任何更改时，您都需要记住要更新代码中的版本号。

可能更好的方法是为每个css或js文件设置一个保证唯一的参数，如下所示：

<script src="scripts/myjavascript.js?_=<%=DateTime.Now.Ticks%>" type="text/javascript"></script>
<link href="styles/mystyle.css?_=<%=DateTime.Now.Ticks%>" rel="stylesheet" type="text/css" />

这会强制每次都从服务器请求文件，这也意味着您的站点在页面加载时不会表现出色，因为这些文件将永远不会被缓存，并且每次都会使用不需要的带宽。

本质上，如果您记得每次进行更改时都会更新版本号，那么您就可以摆脱它的工作方式。

对于ASP.NET页面，我正在使用以下内容

之前

<script src="/Scripts/pages/common.js" type="text/javascript"></script>

之后（强制装弹）

 <script src="/Scripts/pages/common.js?ver<%=DateTime.Now.Ticks.ToString()%>" type="text/javascript"></script>

添加DateTime.Now.Ticks效果很好。