español - mvc asp.net c#

Hacer que un paquete de scripts incluya otro paquete de scripts

Question

Supongamos que tengo estos dos paquetes de scripts configurados:

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

Como puede ver, ~/Scripts/Boostrap usa un archivo jQuery JavaScript y Bootstrap. Esto se debe a que Bootstrap one requiere jQuery para funcionar.

Por otro lado, ~/Scripts/jQuery está compuesto únicamente del archivo jQuery.

Quiero tener dos paquetes en caso de que una vista solo necesite jQuery y no Bootstrap.

Sin embargo, estoy replicando el código aquí, estoy definiendo la ruta del archivo jQuery JavaScript dos veces .

¿Hay alguna manera de decirle al paquete ~/Scripts/Boostrap que use o "inyecte" otro paquete?

Algo como esto:

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

Answer 1

Hacer que un paquete de scripts incluya otro paquete de scripts

No directamente usando la clase de Bundling.

Digamos en su escenario que la empresa decide enviar un solo paquete al cliente para cada solicitud. Has decidido agrupar todos los scripts necesarios para cada controlador (en este mundo mágico). Puedes comenzar con algo como esto:

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

Luego, al darse cuenta de que .Include(string[]) simplemente toma una matriz de string, podría DRY su código en algo como:

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

No recomiendo las razones comerciales detrás de esta solución, pero creo que la lógica que la resuelve puede usarse de manera similar para resolver su problema.

Si crees que posiblemente tendrás duplicados, también podrías:

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

Personalmente, no incluiría jQuery o BootStrap en paquetes, ya que están disponibles en forma gratuita desde muchos CDN en línea que; A significa que uso menos ancho de banda, y B el cliente ya puede haber descargado los scripts que necesito (de todas formas, los CDN existen para los scripts / estilos comunes).

Answer 2

También puede considerar la creación de una clase contenedora ComposableBundle que le permita componer paquetes con la .UseBundle(someBundle) .

Por ejemplo los siguientes métodos de clase y extensiones:

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

Le permitiría configurar sus paquetes de esta manera:

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