Jak używać ASP.Net MVC 4 do pakietu mniej plików w trybie Release?

Jako uzupełnienie zaakceptowanej odpowiedzi , stworzyłem klasę Lessbundle, która jest mniej równoprawną klasą StyleBundle.

LessBundle.kod cs to:

using System.Web.Optimization;

namespace MyProject
{
    public class LessBundle : Bundle
    {
        public LessBundle(string virtualPath) : base(virtualPath, new IBundleTransform[] {new LessTransform(), new CssMinify()})
        {

        }

        public LessBundle(string virtualPath, string cdnPath)
            : base(virtualPath, cdnPath, new IBundleTransform[] { new LessTransform(), new CssMinify() })
        {

        }
    }
}

Użycie jest podobne do klasy StyleBundle, określając plik LESS zamiast pliku CSS.

Dodaj następujące do swojego BundleConfig.RegisterBundles (BundleCollection) metoda:

bundles.Add(new LessBundle("~/Content/less").Include(
                 "~/Content/MyStyles.less"));

Update

Ta metoda działa dobrze przy wyłączonej optymalizacji, ale napotkałem kilka drobnych problemów (ze ścieżkami zasobów CSS) po włączeniu optymalizacji. Po godzinie badań nad tym zagadnieniem odkryłem, że odkryłem na nowo koło...

Jeśli chcesz mieć funkcjonalność LessBundle, którą opisałem powyżej, sprawdź System.Www.Optymalizacja.Mniej .

Pakiet NuGet można znaleźć tutaj .

Zaakceptowana odpowiedź nie działa przy ostatnich zmianach w ASP.NET, więc nie jest już poprawny.

Naprawiłem źródło w zaakceptowanej odpowiedzi:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.Hosting;
using System.Web.Optimization;
using dotless.Core;
using dotless.Core.Abstractions;
using dotless.Core.Importers;
using dotless.Core.Input;
using dotless.Core.Loggers;
using dotless.Core.Parser;

namespace Web.App_Start.Bundles
{
    public class LessTransform : IBundleTransform
    {
        public void Process(BundleContext context, BundleResponse bundle)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (bundle == null)
            {
                throw new ArgumentNullException("bundle");
            }

            context.HttpContext.Response.Cache.SetLastModifiedFromFileDependencies();

            var lessParser = new Parser();
            ILessEngine lessEngine = CreateLessEngine(lessParser);

            var content = new StringBuilder(bundle.Content.Length);

            var bundleFiles = new List<BundleFile>();

            foreach (var bundleFile in bundle.Files)
            {
                bundleFiles.Add(bundleFile);

                var name = context.HttpContext.Server.MapPath(bundleFile.VirtualFile.VirtualPath);
                SetCurrentFilePath(lessParser, name);
                using (var stream = bundleFile.VirtualFile.Open())
                using (var reader = new StreamReader(stream))
                {
                    string source = reader.ReadToEnd();
                    content.Append(lessEngine.TransformToCss(source, name));
                    content.AppendLine();
                }

                bundleFiles.AddRange(GetFileDependencies(lessParser));
            }

            if (BundleTable.EnableOptimizations)
            {
                // include imports in bundle files to register cache dependencies
                bundle.Files = bundleFiles.Distinct();
            }

            bundle.ContentType = "text/css";
            bundle.Content = content.ToString();
        }

        /// <summary>
        /// Creates an instance of LESS engine.
        /// </summary>
        /// <param name="lessParser">The LESS parser.</param>
        private ILessEngine CreateLessEngine(Parser lessParser)
        {
            var logger = new AspNetTraceLogger(LogLevel.Debug, new Http());
            return new LessEngine(lessParser, logger, true, false);
        }

        /// <summary>
        /// Gets the file dependencies (@imports) of the LESS file being parsed.
        /// </summary>
        /// <param name="lessParser">The LESS parser.</param>
        /// <returns>An array of file references to the dependent file references.</returns>
        private IEnumerable<BundleFile> GetFileDependencies(Parser lessParser)
        {
            IPathResolver pathResolver = GetPathResolver(lessParser);

            foreach (var importPath in lessParser.Importer.Imports)
            {
                yield return
                    new BundleFile(pathResolver.GetFullPath(importPath),
                        HostingEnvironment.VirtualPathProvider.GetFile(importPath));
            }

            lessParser.Importer.Imports.Clear();
        }

        /// <summary>
        /// Returns an <see cref="IPathResolver"/> instance used by the specified LESS lessParser.
        /// </summary>
        /// <param name="lessParser">The LESS parser.</param>
        private IPathResolver GetPathResolver(Parser lessParser)
        {
            var importer = lessParser.Importer as Importer;
            var fileReader = importer.FileReader as FileReader;

            return fileReader.PathResolver;
        }

        /// <summary>
        /// Informs the LESS parser about the path to the currently processed file. 
        /// This is done by using a custom <see cref="IPathResolver"/> implementation.
        /// </summary>
        /// <param name="lessParser">The LESS parser.</param>
        /// <param name="currentFilePath">The path to the currently processed file.</param>
        private void SetCurrentFilePath(Parser lessParser, string currentFilePath)
        {
            var importer = lessParser.Importer as Importer;

            if (importer == null)
                throw new InvalidOperationException("Unexpected dotless importer type.");

            var fileReader = importer.FileReader as FileReader;

            if (fileReader == null || !(fileReader.PathResolver is ImportedFilePathResolver))
            {
                fileReader = new FileReader(new ImportedFilePathResolver(currentFilePath));
                importer.FileReader = fileReader;
            }
        }
    }
}

Należy zauważyć, że jeden znany problem z tym kodem jest taki, że mniej @imports musi używać swoich pełnych ścieżek, tzn. musisz użyć @import "~/Areas/Admin/Css/global.less"; zamiast @import "global.less";.

Wygląda na to, że to działa-zmieniłem metodę Process na iterację nad zbiorem plików:

public void Process(BundleContext context, BundleResponse response)
{
    var builder = new StringBuilder();
    foreach (var fileInfo in response.Files)
    {
        using (var reader = fileInfo.OpenText())
        {
            builder.Append(dotless.Core.Less.Parse(reader.ReadToEnd()));
        }
    }

    response.Content = builder.ToString();
    response.ContentType = "text/css";
}

To się psuje, jeśli są jakieś @import instrukcje w Twoich plikach less, w tym przypadku musisz wykonać trochę więcej pracy, jak to: https://gist.github.com/chrisortman/2002958

Już kilka świetnych odpowiedzi, oto bardzo proste rozwiązanie, które znalazłem dla siebie, próbując dodać pakiety MVC, które dotyczą less plików.

Po utworzeniu pliku less (na przykład test.less), Kliknij go prawym przyciskiem myszy i pod Web Compiler (pobierz go tutaj) wybierz opcję Compile File.

Generuje wynikowy plik css z twojego less, a także jego zminifikowaną wersję. (test.css i test.min.css).

W Twoim pakiecie, po prostu zapoznaj się z wygenerowanym css plik

style = new StyleBundle("~/bundles/myLess-styles")
    .Include("~/Content/css/test.css", new CssRewriteUrlTransform());

bundles.Add(style);

A według Ciebie, odwołaj się do tego pakietu:

@Styles.Render("~/bundles/myLess-styles")

To powinno działać dobrze.