Machen Sie ein Skript-Bundle enthalten ein anderes Skript Bündel

Question

Nehmen wir an, ich habe diese beiden Skript konfiguriert Bundles erhältlich:

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

Wie Sie sehen können, ~/Scripts/Boostrap verwendet eine jQuery JavaScript-Datei und eine eine Bootstrap. Der Grund dafür ist, dass der Bootstrap jQuery benötigt, um zu funktionieren.

Auf der anderen Seite besteht ~/Scripts/jQuery nur aus der jQuery-Datei.

Ich möchte zwei Bundles für den Fall, dass eine Ansicht nur jQuery und nicht Bootstrap benötigt.

Allerdings repliziere ich Code hier, ich definiere den jQuery JavaScript-Dateipfad zweimal.

Gibt es eine Möglichkeit zu sagen, das ~/Scripts/Boostrap Bundle zu verwenden oder ein anderes Bündel "injizieren"?

Etwas wie folgt aus:

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

Answer 1

ein Skript-Bundle Stellen umfassen ein anderes Skript-Bundle

Nicht direkt die Bündelung Klasse.

Lassen Sie in Ihrem Szenario sagen, dass das Unternehmen entscheidet, nur ein einzelnes Paket an den Client für jede Anforderung zu senden. Sie haben beschlossen, alle Skripte zu bündeln, die für jeden Controller (in dieser magischen Welt) benötigt werden. Sie könnten mit so etwas wie dies beginnen:

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

ich nicht empfehlen, das Geschäft:

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

Dann erkennen, dass .Include(string[]) einfach nimmt ein Array von String, können Sie Ihren Code in so etwas wie DRY Gründe für diese Lösung, aber ich denke, die Logik, die es löst, könnte ähnlich verwendet werden, um Ihr Problem zu lösen.

Wenn Sie denken, Sie gehen möglicherweise Duplikate haben, könnten Sie auch:

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

Persönlich würde ich nicht jQuery oder BootStrap in Bündeln enthalten, da sie kostenlos von vielen CDNs Online verfügbar sind welche, A bedeutet, dass ich weniger von meiner Bandbreite verwende und B der Client möglicherweise bereits die benötigten Skripte heruntergeladen hat (Die Gründe, CDNs existieren sowieso für gängige Skripte/Stile).

Answer 2

Sie könnten auch eine ComposableBundle Wrapper-Klasse erstellen, die es Ihnen ermöglicht, Bundles mit der .UseBundle(someBundle)-Syntax zu erstellen.

Zum Beispiel die folgende Klasse und Erweiterungen Methoden:

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

erlauben Möchten Sie Bundles wie folgt zu konfigurieren:

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