asp.net-mvc - microsoft - visual studio installer

asp.net mvc excluir archivo css del paquete

Question

tengo tal paquete

bundles.Add(new StyleBundle("~/Content/themes/default/css")
       .IncludeDirectory("~/Content/themes/Default", "*.css"));

pero quiero excluir un archivo css de él. ¿Es posible hacer esto sin especificar cada archivo css en paquete?

Answer 1

Aquí hay otro método de extensión que sobrecarga los métodos de IncludeDirectory existentes y admite la búsqueda de subdirectorios.

public static class BundleExtensions
{
    public static Bundle IncludeDirectory(
        this Bundle bundle,
        string directoryVirtualPath,
        string searchPattern,
        params string[] filesToExclude)
    {
        return IncludeDirectory(bundle, directoryVirtualPath, searchPattern, false, filesToExclude);
    }
    public static Bundle IncludeDirectory(
        this Bundle bundle,
        string directoryVirtualPath,
        string searchPattern,
        bool searchSubdirectories,
        params string[] filesToExclude)
    {
        var physicalPath = HttpContext.Current.Server.MapPath(directoryVirtualPath);
        return bundle.Include(Directory
            .EnumerateFiles(physicalPath, searchPattern, searchSubdirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
            .Select(physicalFileName => physicalFileName.Replace(physicalPath, directoryVirtualPath).Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))
            .Where(virtualFileName => !filesToExclude.Contains(virtualFileName))
            .ToArray());
    }
}

Answer 2

He mejorado la buena sugerencia de Jon Malcolm (y algunas actualizaciones de Satpal here ) para corregir algunas deficiencias que tenía:

1) Rompe el comportamiento predeterminado de los paquetes con ".min". archivos

2) No permite patrones de búsqueda, solo se excluyen archivos.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Optimization;


public static class BundleExtentions
{
    public static Bundle IncludeDirectoryWithExclusion(this Bundle bundle, string directoryVirtualPath, string searchPattern, bool includeSubDirectories, params string[] excludePatterns)
    {
        string folderPath = HttpContext.Current.Server.MapPath(directoryVirtualPath);

        SearchOption searchOption = includeSubDirectories
                                        ? SearchOption.AllDirectories
                                        : SearchOption.TopDirectoryOnly;

        HashSet<string> excludedFiles = GetFilesToExclude(folderPath, searchOption, excludePatterns);
        IEnumerable<string> resultFiles = Directory.GetFiles(folderPath, searchPattern, searchOption)
                                                    .Where(file => !excludedFiles.Contains(file) && !file.Contains(".min."));

        foreach (string resultFile in resultFiles)
        {
            bundle.Include(directoryVirtualPath + resultFile.Replace(folderPath, "")
                    .Replace("//", "/"));
        }

        return bundle;
    }

    private static HashSet<string> GetFilesToExclude(string path, SearchOption searchOptions, params string[] excludePatterns)
    {
        var result = new HashSet<string>();

        foreach (string pattern in excludePatterns)
        {
            result.UnionWith(Directory.GetFiles(path, pattern, searchOptions));
        }

        return result;
    }
}

Un ejemplo de uso que tengo es incluir todas las bibliotecas de la carpeta lib que comienzan con angular, pero excluyendo todos los scripts de configuración regional (porque solo se agregará una basada en el idioma en un paquete aparte más adelante):

bundles.Add(new Bundle("~/bundles/scripts")
                .Include("~/wwwroot/lib/angular/angular.js") // Has to be first
                .IncludeDirectoryWithExclusion("~/wwwroot/lib", "*.js", true, "*.locale.*.js"));

Esto se comportará correctamente si tiene angular.min.js y angular.js y agrega una versión no minada en la depuración y el uso de .min.js existente en la versión.

Answer 3

Intente utilizar IgnoreList.Ignore ; bundles.IgnoreList.Ignore(...) .

Answer 4

Un método de extensión podría ser lo que necesitas aquí:

public static class BundleExtentions
{
    public static Bundle IncludeDirectoryWithExclusion(this StyleBundle bundle, string directoryVirtualPath, string searchPattern, params string[] toExclude)
    {
        var folderPath = HttpContext.Current.Server.MapPath(directoryVirtualPath);

        foreach (var file in Directory.GetFiles(folderPath, searchPattern))
        {
            if (!String.IsNullOrEmpty(Array.Find(toExclude, s => s.ToLower() == file.ToLower())))
            {
                continue;
            }     

            bundle.IncludeFile(directoryVirtualPath + "/" + file);
        }

        return bundle;
}

Y luego el uso debe ser:

bundles.Add(new StyleBundle("~/Content/themes/default/css")
   .IncludeDirectoryWithExclusion("~/Content/themes/Default", "*.css", "file-you-dont-want.css"));

No estoy en una PC en este momento, por lo que lo anterior no está probado, pero debería darle una plantilla para su solución.