Exécution dynamique de regroupement et d'minifying MVC 4

j'ai écrit une fonction d'assistance à la dynamique de rapetisser ma css & js

    public static IHtmlString RenderStyles(this HtmlHelper helper, params string[] additionalPaths)
{
var page = helper.ViewDataContainer as WebPageExecutingBase;
if (page != null && page.VirtualPath.StartsWith("~/"))
{
var virtualPath = "~/bundles" + page.VirtualPath.Substring(1);
if (BundleTable.Bundles.GetBundleFor(virtualPath) == null)
{
var defaultPath = page.VirtualPath + ".css";
BundleTable.Bundles.Add(new StyleBundle(virtualPath).Include(defaultPath).Include(additionalPaths));
}
return MvcHtmlString.Create(@"<link href=""" + HttpUtility.HtmlAttributeEncode(BundleTable.Bundles.ResolveBundleUrl(virtualPath)) + @""" stylesheet""/>");
}
return MvcHtmlString.Empty;
}
public static IHtmlString RenderScripts(this HtmlHelper helper, params string[] additionalPaths)
{
var page = helper.ViewDataContainer as WebPageExecutingBase;
if (page != null && page.VirtualPath.StartsWith("~/"))
{
var virtualPath = "~/bundles" + page.VirtualPath.Substring(1);
if (BundleTable.Bundles.GetBundleFor(virtualPath) == null)
{
var defaultPath = page.VirtualPath + ".js";
BundleTable.Bundles.Add(new ScriptBundle(virtualPath).Include(defaultPath).Include(additionalPaths));
}
return MvcHtmlString.Create(@"<script src=""" + HttpUtility.HtmlAttributeEncode(BundleTable.Bundles.ResolveBundleUrl(virtualPath)) + @"""></script>");
}
return MvcHtmlString.Empty;
}

utilisation

~/views/Home/Test1.cshtml

~/Views/Home/Test1.cshtml.css

~/Views/Home/Test1.cshtml.js

dans Test1.cshtml

@model object
@{
//init
}@{
}@section MainContent {
{<div>@{
if ("work" != "fun")
{
{<hr/>}
}
}</div>}
}@{
}@section Scripts {@{
{@Html.RenderScripts()}
}@{
}@section Styles {@{
{@Html.RenderStyles()}
}}

mais ofcoz, j'ai mis la plupart de mon sripts,styles dans ~/Scripts/.js, ~/Content/.css

et les enregistrer dans Appp_Start

Mise à jour: je ne sais Pas si c'est important mais je suis en utilisant MVC 5.2.3 et Visual Studio 2015, la question est un peu ancien.

Cependant j'ai fait dynamique de regroupement qui travaille dans _viewStart.cshtml. Ce que j'ai fait j'ai fait une classe helper qui stocke les bundles dans un dictionnaire de faisceaux. Puis à l'application de commencer, j'ai tirer dans le dictionnaire, et les enregistrer. Et j'ai fait une statique boolen "bundlesInitialzed" afin que les paquets seulement ajouter dans le dictionnaire une fois.

Exemple Helper:

public static class KBApplicationCore: .....
{
private static Dictionary<string, Bundle> _bundleDictionary = new Dictionary<string, Bundle>();
public static bool BundlesFinalized { get { return _BundlesFinalized; } }
///<summary>
///Add a bundle to the bundle dictionary
///</summary>
///<param name="bundle"></param>
///<returns></returns>
public static bool RegisterBundle(Bundle bundle)
{
if (bundle == null)
throw new ArgumentNullException("bundle");
if (_BundlesFinalized)
throw new InvalidOperationException("The bundles have been finalized and frozen, you can only finalize the bundles once as an app pool recycle is needed to change the bundles afterwards!");
if (_bundleDictionary.ContainsKey(bundle.Path))
return false;
_bundleDictionary.Add(bundle.Path, bundle);
return true;
}
///<summary>
///Finalize the bundles, which commits them to the BundleTable.Bundles collection, respects the web.config's debug setting for optimizations
///</summary>
public static void FinalizeBundles()
{
FinalizeBundles(null);
}
///<summary>
///Finalize the bundles, which commits them to the BundleTable.Bundles collection
///</summary>
///<param name="forceMinimize">Null = Respect web.config debug setting, True force minification regardless of web.config, False force no minification regardless of web.config</param>
public static void FinalizeBundles(bool? forceMinimize)
{
var bundles = BundleTable.Bundles;
foreach (var bundle in _bundleDictionary.Values)
{
bundles.Add(bundle);
}
if (forceMinimize != null)
BundleTable.EnableOptimizations = forceMinimize.Value;
_BundlesFinalized = true;
}        
}

Exemple _ViewStart.cshtml

@{
var bundles = BundleTable.Bundles;
var baseUrl = string.Concat("~/App_Plugins/", KBApplicationCore.PackageManifest.FolderName, "/");
//Maybe there is a better way to do this, the goal is to make the bundle configurable without having to recompile the code
if (!KBApplicationCore.BundlesFinalized)
{
//Note, you need to reset the application pool in order for any changes here to be reloaded as the BundlesFinalized property is a static field that will only reset to false when the app restarts.
Bundle mainScripts = new ScriptBundle("~/bundles/scripts/main.js");
mainScripts.Include(new string[] {
baseUrl + "Assets/lib/jquery/jquery.js",
baseUrl + "Assets/lib/jquery/plugins/jqcloud/jqcloud.js",
baseUrl + "Assets/lib/bootstrap/js/bootstrap.js",            
baseUrl + "Assets/lib/bootstrap/plugins/treeview/bootstrap-treeview.js",   
baseUrl + "Assets/lib/angular/angular.js",
baseUrl + "Assets/lib/ckEditor/ckEditor.js"      
});
KBApplicationCore.RegisterBundle(mainScripts);
Bundle appScripts = new ScriptBundle("~/bundles/scripts/app.js");
appScripts.Include(new string[] {
baseUrl + "Assets/app/app.js",
baseUrl + "Assets/app/services/*.js",
baseUrl + "Assets/app/directives/*.js",
baseUrl + "Assets/app/controllers/*.js"
});
KBApplicationCore.RegisterBundle(appScripts);
Bundle mainStyles = new StyleBundle("~/bundles/styles/main.css");
mainStyles.Include(new string[] {
baseUrl + "Assets/lib/bootstrap/build/less/bootstrap.less",
baseUrl + "Assets/lib/bootstrap/plugins/treeview/bootstrap-treeview.css",   
baseUrl + "Assets/lib/ckeditor/contents.css",
baseUrl + "Assets/lib/font-awesome/less/font-awesome.less",
baseUrl + "Assets/styles/tlckb.less"
});
mainStyles.Transforms.Add(new BundleTransformer.Core.Transformers.CssTransformer());
mainStyles.Transforms.Add(new CssMinify());
mainStyles.Orderer = new BundleTransformer.Core.Orderers.NullOrderer();
KBApplicationCore.RegisterBundle(mainStyles);
KBApplicationCore.FinalizeBundles(true); //true = Force Optimizations, false = Force non Optmizations, null = respect web.config which is the same as calling the parameterless constructor.
}
}

Remarque: il doit être mis à jour pour utiliser filetage de verrouillage pour empêcher les 2 demandes entrant dans le bundle de code avant la première sortie.

La façon dont cela fonctionne est la vue de démarrage s'exécute sur le premier demande au site après une application de la piscine de réinitialisation. Il appelle la RegisterBundle sur l'aide et passe le ScriptBundle ou StyleBundle le dictionnaire dans l'ordre RegisterBundles est appelé.

Quand FinalizeBundles est appelée, vous pouvez spécifier Vrai qui va forcer les optimisations indépendamment de web.config paramètre debug, ou le laisser à null, ou utilisez le constructeur sans paramètre de l'avoir à l'égard du web.paramètre de configuration. Passant false va l'obliger à utiliser sans optimisation, même si le débogage est vrai. FinalizeBundles Enregistre les paquets dans les paquets de la table et du jeu de _BundlesFinalized de vrai.

Une fois finalisé, une tentative de faire appel RegisterBundle de nouveau lever une exception, c'est gelé au point.

Cette configuration vous permet d'ajouter de nouveaux paquets à la vue de début et de réinitialiser l'application de la piscine pour les amener à prendre effet. L'objectif de départ, j'avais écrit que c'était parce que je fais quelque chose que les autres utilisera donc je voulais être en mesure de changer complètement la face avant de l'INTERFACE utilisateur sans avoir à reconstruire la source pour modifier les paquets.