Paquetes de ASP.NET cómo deshabilitar la minificación

Tengo debug="true"en mi web.config (s) , y simplemente no quiero que mis paquetes se minimicen, pero nada de lo que hago parece deshabilitarlo. Lo intenté enableoptimisations=false, aquí está mi código:

//Javascript
bundles.Add(new ScriptBundle("~/bundles/MainJS")
            .Include("~/Scripts/regular/lib/mvc/jquery.validate.unobtrusive.js*")
            .Include("~/Scripts/regular/lib/mvc/jquery.validate*")
            .Include("~/Scripts/regular/lib/bootstrap.js")
            .IncludeDirectory("~/Scripts/regular/modules", "*.js", true)
            .IncludeDirectory("~/Scripts/regular/pages", "*.js", true)
            .IncludeDirectory("~/Scripts/regular/misc", "*.js", true));

//CSS
bundles.Add(new StyleBundle("~/bundles/MainCSS")
            .Include("~/Content/css/regular/lib/bootstrap.css*")
            .IncludeDirectory("~/Content/css/regular/modules", "*.css", true)
            .IncludeDirectory("~/Content/css/regular/pages", "*.css", true))

Si tiene debug="true"en web.config y está utilizando Scripts/Styles.Renderpara hacer referencia a los paquetes en sus páginas, eso debería desactivar tanto la agrupación como la minificación. BundleTable.EnableOptimizations = falsesiempre desactivará tanto la agrupación como la minificación (independientemente del indicador de depuración verdadero / falso).

¿Quizás no estás usando los Scripts/Styles.Renderayudantes? Si representa directamente las referencias al paquete BundleTable.Bundles.ResolveBundleUrl(), siempre obtendrá el contenido minimizado / incluido.

Las directivas de compilación condicional son tu amigo:

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

Para deshabilitar la agrupación y la minificación, simplemente coloque este su archivo .aspx (esto deshabilitará la optimización incluso si está debug=trueen web.config )

vb.net:

System.Web.Optimization.BundleTable.EnableOptimizations = false

c # .net

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

Si coloca EnableOptimizations = trueesto, se agrupará y minimizará incluso si está debug=trueen web.config

Puede desactivar la minificación en sus paquetes simplemente borrando sus transformaciones.

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

Personalmente, esto me pareció útil cuando quería agrupar todos mis scripts en un solo archivo, pero necesitaba legibilidad durante las fases de depuración.

Intenté muchas de estas sugerencias, pero notar que parecía funcionar. He perdido bastantes horas solo para descubrir que este fue mi error:

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

Siempre me ha minimizado y agrupado javascript, sin importar lo que haya intentado. En cambio, debería haber usado esto:

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

El '~' extra lo hizo. Incluso lo eliminé nuevamente en una sola instancia para ver si realmente era así. Fue ... espero poder salvar al menos a una persona las horas que desperdicié en esto.

Combine varias respuestas, esto funciona para mí en 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

También hay una forma sencilla de controlar la minificación (y otras características) de forma manual. Es el nuevo transformador CssMinify () que usa, como este:

// 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();

Eso es conveniente cuando quieres tener algunos paquetes de parte especial solo para ser minimizados. Digamos que está utilizando algunos estilos estándar (jQuery), que se están poniendo bajo sus pies (recibiendo muchas solicitudes excesivas del navegador), pero desea mantener sin minificar su propia hoja de estilos. (Lo mismo, con javascript).

Combiné algunas respuestas dadas por otros en esta pregunta para llegar a otra solución alternativa.

Objetivo: siempre agrupar los archivos, deshabilitar la minificación JS y CSS en caso de que <compilation debug="true" ... />y aplicar siempre una transformación personalizada al paquete CSS.

Mi solucion :

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

2) En el método 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()));
     ...
}

Si establece la siguiente propiedad en false, deshabilitará tanto la agrupación como la minificación.

En el archivo Global.asax.cs , agregue la línea como se menciona a continuación

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

Aquí se explica cómo deshabilitar la minificación por paquete:

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

Nota al margen: las rutas utilizadas para sus paquetes no deben coincidir con ninguna ruta real en sus compilaciones publicadas, de lo contrario, nada funcionará. También asegúrese de evitar el uso de .js, .css y / o '.' y '_' en cualquier parte del nombre del paquete. Mantenga el nombre lo más simple y directo posible, como en el ejemplo anterior.

Las clases auxiliares se muestran a continuación. Tenga en cuenta que para hacer que estas clases estén preparadas para el futuro, eliminamos quirúrgicamente las instancias de minería js / css en lugar de usar .clear () y también insertamos una transformación mime-type-setter sin la cual las compilaciones de producción seguramente tendrán problemas, especialmente cuando se trata de entregar correctamente los paquetes css (firefox y chrome rechazan los paquetes css con el tipo mime establecido en "text / html", que es el valor predeterminado):

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;
        }
}

Para que todo funcione, debe instalar (a través de nuget):

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

Y su web.config debería enriquecerse así:

<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>

Tenga en cuenta que es posible que tenga que tomar medidas adicionales para que sus paquetes css funcionen en términos de fuentes, etc. Pero esa es una historia diferente.

Solo para complementar las respuestas ya dadas, si también NO desea minimizar / ofuscar / concatenar ALGUNOS archivos mientras aún permite la agrupación completa y la minificación para otros archivos, la mejor opción es ir con un renderizador personalizado que lea el contenido de un paquete en particular (s) y renderizar los archivos en la página en lugar de representar la ruta virtual del paquete. Personalmente, lo requería porque IE 9 costaba $ *% en la cama cuando mis archivos CSS se agrupaban incluso con la minificación desactivada .

Muchas gracias a este artículo , que me dio el punto de partida para el código que utilicé para crear un Renderizador CSS que representaría los archivos para el CSS pero aún permitiría que el sistema procese mis archivos javascript agrupados / minificados / ofuscados.

Creó la clase auxiliar estática:

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);
    }
  }

}

Luego, en el archivo de diseño de la maquinilla de afeitar:

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

en lugar del estándar:

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

Estoy seguro de que crear un renderizador opcional para archivos javascript también necesitaría poco para actualizar a este asistente.

Busque la EnableOptimizationspalabra clave en su proyecto

Entonces si encuentras

BundleTable.EnableOptimizations = true;

dale la vuelta false.

Si está utilizando la transformación CSS LESS / SASS, hay una opción useNativeMinificationque se puede establecer en falso para deshabilitar la minificación (en web.config). Para mis propósitos, solo lo cambio aquí cuando lo necesito, pero podría usar transformaciones web.config para habilitarlo siempre en la versión de lanzamiento o tal vez encontrar una forma de modificarlo en el código.

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

Consejo: El objetivo de esto es ver su CSS, lo que puede hacer en el navegador para inspeccionar las herramientas o simplemente abriendo el archivo. Cuando se habilita la agrupación, ese nombre de archivo cambia en cada compilación, por lo que pongo lo siguiente en la parte superior de mi página para que pueda ver fácilmente mi CSS compilado en una nueva ventana del navegador cada vez que cambia.

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

esta será una URL dinámica algo así como https://example.com/Content/css/bundlename?v=UGd0FjvFJz3ETxlNN9NVqNOeYMRrOkQAkYtB04KisCQ1

Actualización: creé una transformación web.config para configurarlo como verdadero durante la implementación / lanzamiento

  <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>

Esto puede llegar a ser útil a alguien en el futuro como el nuevo marco, cuando la configuración a través de VS, consigue un defecto web.config, web.Debug.configy web.Release.config. En el web.release.configencontrarás esta línea:

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

Esto parecía anular cualquier cambio en línea que hice. Comenté esta línea y estábamos en salsa (en términos de ver código no minimizado en una compilación de "lanzamiento")