fare un pacco di script includono un altro fascio di script

Question

Supponiamo che ho scritto questi due bundle configurato:

bundles.Add(new ScriptBundle("~/Scripts/Bootstrap").Include(
     "~/Content/Scripts/jQuery/jquery-2.1.1.js", 
     "~/Content/Scripts/Bootstrap/bootstrap.js")); 

bundles.Add(new ScriptBundle("~/Scripts/jQuery").Include(
     "~/Content/Scripts/jQuery/jquery-2.1.1.js")); 

Come si può vedere, ~/Scripts/Boostrap utilizza un file di jQuery Javascript e uno Bootstrap. Questo perché Bootstrap richiede jQuery per funzionare.

D'altra parte, ~/Scripts/jQuery è composto solo dal file jQuery.

Voglio avere due bundle nel caso in cui una vista necessiti solo di jQuery e non di Bootstrap.

Tuttavia, sto replicando il codice qui, sto definendo il percorso file jQuery JavaScript due volte.

C'è un modo per dire al pacchetto ~/Scripts/Boostrap di utilizzare o "iniettare" un altro pacchetto?

Qualcosa di simile a questo:

bundles.Add(new ScriptBundle("~/Scripts/Bootstrap").UseBundle("~/Scripts/jQuery").Include(
     "~/Content/Scripts/Bootstrap/bootstrap.js")); 

Answer 1

fare un pacco di script includono un altro fascio di script

Non direttamente utilizzando la classe Bundling.

Diciamo nel vostro scenario che l'azienda decide di inviare solo un singolo pacchetto al client per ogni richiesta. Hai deciso di raggruppare tutti gli script necessari per ciascun controller (in questo mondo magico). Si potrebbe iniziare con qualcosa di simile:

bundles.Add(new ScriptBundle("~/Scripts/Home") 
       .Include("~/Content/Scripts/jQuery/jquery-2.1.1.js", 
         "~/Content/Scripts/Bootstrap/bootstrap.js" 
         "~/Content/Scripts/Home.js")); 

bundles.Add(new ScriptBundle("~/Scripts/Account") 
       .Include("~/Content/Scripts/jQuery/jquery-2.1.1.js", 
         "~/Content/Scripts/Bootstrap/bootstrap.js" 
         "~/Content/Scripts/Account.js")); 

Poi rendendosi conto che .Include(string[]) prende semplicemente un array di stringhe, si potrebbe DRY il codice in qualcosa di simile:

var commonScripts = new List<string>() 
{ 
    "~/Content/Scripts/jQuery/jquery-2.1.1.js", 
    "~/Content/Scripts/Bootstrap/bootstrap.js" 
}; 

var homeScripts = new List<string>() 
{ 
    "~/Content/Scripts/Home.js" 
}; 

bundles.Add(new ScriptBundle("~/bundles/home/") 
       .Include(commonScripts.Concat(homeScripts).ToArray())); 

var accountScripts = new List<string>() 
{ 
    "~/Content/Scripts/Account.js" 
}; 

bundles.Add(new ScriptBundle("~/bundles/account/") 
       .Include(commonScripts.Concat(accountScripts).ToArray())); 

Non consiglio il business ragioni alla base di questa soluzione, ma penso che la logica che la risolve possa essere utilizzata allo stesso modo per risolvere il tuo problema.

Se si pensa che si sta andando ad avere possibilmente duplicati si potrebbe anche:

   .Include(commonScripts.Concat(accountScripts) 
             .Distinct() 
             .ToArray())); 

Personalmente non includo jQuery o BootStrap in fasci, in quanto sono disponibili da molti CDN online gratuitamente che; Un mezzo che utilizzo meno della mia larghezza di banda, e B il client potrebbe aver già scaricato gli script di cui ho bisogno (I motivi per cui esistono CDN per script/stili comuni).

Answer 2

Si potrebbe anche considerare di creare una classe di wrapper ComposableBundle che consente di comporre bundle con la sintassi .UseBundle(someBundle).

Per esempio la classe e estensioni seguenti metodi:

public class ComposableBundle<T> where T : Bundle 
{ 
    private T _bundle; 
    private List<string> _virtualPaths = new List<string>(); 

    public ComposableBundle(T bundle) 
    { 
     _bundle = bundle; 
    } 

    public string[] VirtualPaths 
    { 
     get { return _virtualPaths.ToArray(); } 
    } 

    public T Bundle 
    { 
     get { return _bundle; } 
    } 

    public ComposableBundle<T> Include(params string[] virtualPaths) 
    { 
     _virtualPaths.AddRange(virtualPaths); 
     _bundle.Include(virtualPaths); 
     return this; 
    } 

    public ComposableBundle<T> UseBundle(ComposableBundle<T> bundle) 
    { 
     _bundle.Include(bundle.VirtualPaths.ToArray()); 
     return this; 
    } 
} 

public static class BundleExtensions 
{ 
    public static ComposableBundle<T> AsComposable<T>(this T bundle) where T : Bundle 
    { 
     return new ComposableBundle<T>(bundle); 
    } 

    public static ComposableBundle<T> Add<T>(this BundleCollection bundles, ComposableBundle<T> bundle) where T: Bundle 
    { 
     bundles.Add(bundle.Bundle); 
     return bundle; 
    } 
} 

ti permettono di configurare i bundle in questo modo:

var jQueryBundle = bundles.Add(new ScriptBundle("~/bundles/jquery").AsComposable() 
          .Include("~/Scripts/jquery-{version}.js")); 

bundles.Add(new ScriptBundle("~/bundles/jqueryui").AsComposable() 
       .UseBundle(jQueryBundle) 
       .Include("~/Scripts/jquery-ui-{version}.js"));