ASP.NET связывает, как отключить минимизацию

Ответ 1

Если у вас есть debug="true" в web.config и используются Scripts/Styles.Render для ссылки на узлы на ваших страницах, это должно отключить как комплектацию, так и минимизацию. EnableOptimizations = false всегда будет отключать как связывание, так и минимизацию (независимо от флага debug true/false).

Возможно, вы не используете помощники Scripts/Styles.Render? Если вы непосредственно передаете ссылки на пакет через BundleTable.Bundles.ResolveBundleUrl(), вы всегда будете получать мини-контент/связанный контент.

Ответ 2

Условные директивы компиляции - ваш друг:

#if DEBUG
            var jsBundle = new Bundle("~/Scripts/js");
#else
            var jsBundle = new ScriptBundle("~/Scripts/js");
#endif

Ответ 3

Чтобы отключить объединение и минимизацию, просто поместите этот файл .aspx(это отключит оптимизацию, даже если debug=true в web.config)

vb.net:

System.Web.Optimization.BundleTable.EnableOptimizations = false

С#.NET

System.Web.Optimization.BundleTable.EnableOptimizations = false;

Если вы поместите EnableOptimizations = true, это будет связывать и минимизировать, даже если debug=true в web.config

Ответ 4

Вы можете отключить минимизацию в своих пакетах, просто очистив свои преобразования.

var scriptBundle = new ScriptBundle("~/bundles/scriptBundle");
...
scriptBundle.Transforms.Clear();

Я лично нашел это полезным, когда захотел объединить все мои сценарии в одном файле, но нуждался в удобочитаемости на этапах отладки.

Ответ 5

Я пробовал много этих предложений, но, похоже, работала. Я потратил немало времени, чтобы узнать, что это была моя ошибка:

@Scripts.Render("/bundles/foundation")

Он всегда меня заминировал и связал javascript, независимо от того, что я пробовал. Вместо этого я должен был использовать это:

@Scripts.Render("~/bundles/foundation")

Дополнительный '~' сделал это. Я даже удалил его снова только в одном экземпляре, чтобы убедиться, что это действительно так. Это было... надеюсь, я смогу спасти хотя бы одного человека в те часы, которые я потратил на это.

Ответ 6

Объедините несколько ответов, это работает для меня в ASP.NET MVC 4.

        bundles.Add(new ScriptBundle("~/Scripts/Common/js")
            .Include("~/Scripts/jquery-1.8.3.js")
            .Include("~/Scripts/zizhujy.com.js")
            .Include("~/Scripts/Globalize.js")
            .Include("~/Scripts/common.js")
            .Include("~/Scripts/requireLite/requireLite.js"));

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

        bundles.Add(new StyleBundle("~/Content/css/App/FunGrapherStyles")
            .Include("~/Content/css/Apps/FunGrapher.css")
            .Include("~/Content/css/tables.css"));

#if DEBUG
        foreach (var bundle in BundleTable.Bundles)
        {
            bundle.Transforms.Clear();
        }
#endif

Ответ 7

Существует также простой способ управления минимизацией (и другими функциями) вручную. Он новый трансформатор CssMinify(), используя это:

// this is in case when BundleTable.EnableOptimizations = false;
var myBundle = new StyleBundle("~/Content/themes/base/css")
    .Include("~/Content/themes/base/jquery.ui.core.css" /* , ... and so on */);
myBundle.Transforms.Add(new CssMinify());
bundles.Add(myBundle);

// or you can remove that transformer in opposite situation
myBundle.Transforms.Clear();

Это удобно, когда вы хотите, чтобы какая-то часть пакета была только для того, чтобы быть уменьшенной. Скажем, вы используете некоторые стандартные стили (jQuery), которые попадают под ваши ноги (при этом у них много лишних запросов браузеров), но вы хотите сохранить unminified свою собственную таблицу стилей. (То же самое - с javascript).

Ответ 8

Я объединил несколько ответов, заданных другими в этом вопросе, чтобы придумать другое альтернативное решение.

Цель: Всегда связывать файлы, чтобы отключить миниатюра JS и CSS в случае <compilation debug="true" ... /> и всегда применять настраиваемое преобразование к набору CSS.

Мое решение:

1) В web.config: <compilation debug="true" ... />

2) В методе Global.asax Application_Start():

 protected void Application_Start() {
     ...
     BundleTable.EnableOptimizations = true; // Force bundling to occur

     // If the compilation node in web.config indicates debugging mode is enabled
     // then clear all transforms. I.e. disable Js and CSS minification.
     if (HttpContext.Current.IsDebuggingEnabled) {
         BundleTable.Bundles.ToList().ForEach(b => b.Transforms.Clear());
     }

      // Add a custom CSS bundle transformer. In my case the transformer replaces a
      // token in the CSS file with an AppConfig value representing the website URL
      // in the current environment. E.g. www.mydevwebsite in Dev and
      // www.myprodwebsite.com in Production.
      BundleTable.Bundles.ToList()
          .FindAll(x => x.GetType() == typeof(StyleBundle))
          .ForEach(b => b.Transforms.Add(new MyStyleBundleTransformer()));
     ...
}

Ответ 9

Чтобы дополнить уже полученные ответы, если вы также хотите НЕ минимизировать/обфускать/конкатенировать НЕКОТОРЫЕ файлы, сохраняя при этом полное связывание и минимизацию для других файлов, лучший вариант - пойти с пользовательским который будет считывать содержимое конкретного пакета (-ов) и отображать файлы на странице, а не отображать виртуальный путь пакета. Я лично это требовал, потому что IE 9 был $*% @на кровати, когда мои файлы CSS были в комплекте , даже при выключенном отключении.

Большое спасибо этой статье, которая дала мне исходную точку для кода, который я использовал для создания рендерера CSS, который файлы для CSS, но все же позволяют системе визуализировать мои файлы javascript в комплекте/минифицированы/обфускации.

Создал статический вспомогательный класс:

using System;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Web.Optimization;

namespace Helpers
{
  public static class OptionalCssBundler
  {
    const string CssTemplate = "<link href=\"{0}\" rel=\"stylesheet\" type=\"text/css\" />";

    public static MvcHtmlString ResolveBundleUrl(string bundleUrl, bool bundle)
    {
      return bundle ? BundledFiles(BundleTable.Bundles.ResolveBundleUrl(bundleUrl)) : UnbundledFiles(bundleUrl);
    }

    private static MvcHtmlString BundledFiles(string bundleVirtualPath)
    {
      return new MvcHtmlString(string.Format(CssTemplate, bundleVirtualPath));
    }

    private static MvcHtmlString UnbundledFiles(string bundleUrl)
    {
      var bundle = BundleTable.Bundles.GetBundleFor(bundleUrl);

      StringBuilder sb = new StringBuilder();
      var urlHelper = new UrlHelper(HttpContext.Current.Request.RequestContext);

      foreach (BundleFile file in bundle.EnumerateFiles(new BundleContext(new HttpContextWrapper(HttpContext.Current), BundleTable.Bundles, bundleUrl)))
      {
        sb.AppendFormat(CssTemplate + Environment.NewLine, urlHelper.Content(file.VirtualFile.VirtualPath));
      }

      return new MvcHtmlString(sb.ToString());
    }

    public static MvcHtmlString Render(string bundleUrl, bool bundle)
    {
      return ResolveBundleUrl(bundleUrl, bundle);
    }
  }

}

Затем в файле макета бритвы:

@OptionalCssBundler.Render("~/Content/css", false)

вместо стандарта:

@Styles.Render("~/Content/css")

Я уверен, что создание необязательного средства рендеринга для файлов javascript потребуется немного для обновления этому помощнику.

Ответ 10

Если вы установите для этого свойства значение false, оно отключит как связывание, так и минимизацию.

В Global.asax.cs

protected void Application_Start()
{
    System.Web.Optimization.BundleTable.EnableOptimizations = false;
}

Ответ 11

Если вы используете преобразование CSS LESS/SASS, есть опция useNativeMinification, которая может быть установлена ​​в значение false, чтобы отключить мини-настройку (в web.config). Для моих целей я просто изменяю его здесь, когда мне это нужно, но вы можете использовать преобразования web.config, чтобы всегда включать его в сборку релиза или, возможно, найти способ изменить его в коде.

<less useNativeMinification="false" ieCompat="true" strictMath="false"
      strictUnits="false" dumpLineNumbers="None">

Совет. Все это - просмотр вашего CSS, который вы можете сделать в браузере, чтобы проверить инструменты или просто открыть файл. Когда связывание включено, имя файла изменяется на каждом компиляторе, поэтому я помещаю следующее в начало моей страницы, чтобы каждый раз, когда он менялся, я мог просматривать свой скомпилированный CSS eaily в новом окне браузера.

@if (Debugger.IsAttached) 
{
    <a href="@Styles.Url(ViewBag.CSS)" target="css">View CSS</a>
}

это будет динамический URL-адрес, похожий на https://example.com/Content/css/bundlename?v=UGd0FjvFJz3ETxlNN9NVqNOeYMRrOkQAkYtB04KisCQ1

Обновление: я создал преобразование web.config, чтобы установить для него значение true во время сборки развертывания/выпуска

  <bundleTransformer xmlns="http://tempuri.org/BundleTransformer.Configuration.xsd">
    <less xdt:Transform="Replace" useNativeMinification="true" ieCompat="true" strictMath="false" strictUnits="false" dumpLineNumbers="None">
      <jsEngine name="MsieJsEngine" />
    </less>
  </bundleTransformer>

Ответ 12

Это может стать полезным для кого-то в будущем, поскольку новая структура при настройке через VS получает значения по умолчанию web.config, web.Debug.config и web.Release.config. В web.Release.config вы найдете эту строку:

<compilation xdt:Transform="RemoveAttributes(debug)" />

это, казалось, отменяет любые встроенные изменения, которые я сделал. Я прокомментировал эту строку, и мы были подливными (с точки зрения просмотра неминифицированного кода в сборке "release" )

Ответ 13

Здесь, как отключить минимизацию на основе каждого пакета:

bundles.Add(new StyleBundleRaw("~/Content/foobarcss").Include("/some/path/foobar.css"));
bundles.Add(new ScriptBundleRaw("~/Bundles/foobarjs").Include("/some/path/foobar.js"));

Sidenote: пути, используемые для ваших пакетов, не должны совпадать с каким-либо фактическим путем в ваших опубликованных сборках, иначе ничего не получится. Также избегайте использования .js,.css и/или '.' и '_' где угодно во имя связки. Держите имя максимально простым и простым, как в приведенном выше примере.

Ниже перечислены вспомогательные классы. Обратите внимание, что для того, чтобы сделать эти классы перспективными, мы хирургически удаляем js/css minifying экземпляры вместо использования .clear(), и мы также вставляем трансформацию типа mime-setter, без которой производственные сборки неизбежно сталкиваются с проблемами, особенно когда он подходит для правильной передачи css-пакетов (пакетов firefox и chrome reject css с типом mime-типа, установленным в "text/html", который является значением по умолчанию):

internal sealed class StyleBundleRaw : StyleBundle
{
        private static readonly BundleMimeType CssContentMimeType = new BundleMimeType("text/css");

        public StyleBundleRaw(string virtualPath) : this(virtualPath, cdnPath: null)
        {
        }

        public StyleBundleRaw(string virtualPath, string cdnPath) : base(virtualPath, cdnPath)
        {
                 Transforms.Add(CssContentMimeType); //0 vital
                 Transforms.Remove(Transforms.FirstOrDefault(x => x is CssMinify)); //0
        }
        //0 the guys at redmond in their infinite wisdom plugged the mimetype "text/css" right into cssminify    upon unwiring the minifier we
        //  need to somehow reenable the cssbundle to specify its mimetype otherwise it will advertise itself as html and wont load
}

internal sealed class ScriptBundleRaw : ScriptBundle
{
        private static readonly BundleMimeType JsContentMimeType = new BundleMimeType("text/javascript");

        public ScriptBundleRaw(string virtualPath) : this(virtualPath, cdnPath: null)
        {
        }

        public ScriptBundleRaw(string virtualPath, string cdnPath) : base(virtualPath, cdnPath)
        {
                 Transforms.Add(JsContentMimeType); //0 vital
                 Transforms.Remove(Transforms.FirstOrDefault(x => x is JsMinify)); //0
        }
        //0 the guys at redmond in their infinite wisdom plugged the mimetype "text/javascript" right into jsminify   upon unwiring the minifier we need
        //  to somehow reenable the jsbundle to specify its mimetype otherwise it will advertise itself as html causing it to be become unloadable by the browsers in published production builds
}

internal sealed class BundleMimeType : IBundleTransform
{
        private readonly string _mimeType;

        public BundleMimeType(string mimeType) { _mimeType = mimeType; }

        public void Process(BundleContext context, BundleResponse response)
        {
                 if (context == null)
                          throw new ArgumentNullException(nameof(context));
                 if (response == null)
                          throw new ArgumentNullException(nameof(response));

         response.ContentType = _mimeType;
        }
}

Чтобы сделать все это, вам нужно установить (через nuget):

WebGrease 1.6.0+ Microsoft.AspNet.Web.Optimization 1.1.3 +

И ваш web.config должен быть обогащен следующим образом:

<runtime>
       [...]
       <dependentAssembly>
        <assemblyIdentity name="System.Web.Optimization" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0-x.y.z.t" newVersion="x.y.z.t" />
       </dependentAssembly>
       <dependentAssembly>
              <assemblyIdentity name="WebGrease" publicKeyToken="31bf3856ad364e35" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-x.y.z.t" newVersion="x.y.z.t" />
       </dependentAssembly>
        [...]
</runtime>

<!-- setting mimetypes like we do right below is absolutely vital for published builds because for some reason the -->
<!-- iis servers in production environments somehow dont know how to handle otf eot and other font related files   -->
</system.webServer>
        [...]
        <staticContent>
      <!-- in case iis already has these mime types -->
      <remove fileExtension=".otf" />
      <remove fileExtension=".eot" />
      <remove fileExtension=".ttf" />
      <remove fileExtension=".woff" />
      <remove fileExtension=".woff2" />

      <mimeMap fileExtension=".otf" mimeType="font/otf" />
      <mimeMap fileExtension=".eot" mimeType="application/vnd.ms-fontobject" />
      <mimeMap fileExtension=".ttf" mimeType="application/octet-stream" />
      <mimeMap fileExtension=".woff" mimeType="application/font-woff" />
      <mimeMap fileExtension=".woff2" mimeType="application/font-woff2" />
      </staticContent>

      <!-- also vital otherwise published builds wont work  https://stackoverflow.com/a/13597128/863651  -->
      <modules runAllManagedModulesForAllRequests="true">
         <remove name="BundleModule" />
         <add name="BundleModule" type="System.Web.Optimization.BundleModule" />
      </modules>
      [...]
</system.webServer>

Обратите внимание, что вам, возможно, придется предпринять дополнительные шаги, чтобы ваши css-пакеты работали с точки зрения шрифтов и т.д. Но это другая история.