C# Minifier.MinifyStyleSheet方法代码示例

 public string CompressContent(string content)
 {
     var minifier = new Minifier();
     if (settings != null)
     {
         return minifier.MinifyStyleSheet(content, settings);
     }
     return minifier.MinifyStyleSheet(content);
 }

        public string Minify(string content)
        {
            var minifier = new Minifier();
            var stylesheet = string.Empty;

            stylesheet = Settings != null 
                ? minifier.MinifyStyleSheet(content, Settings) 
                : minifier.MinifyStyleSheet(content);

            return stylesheet;
        }

        public string Minify(string content)
        {
            var minifier = new Minifier();
            var stylesheet = string.Empty;

            if (Settings != null)
            {
                stylesheet = minifier.MinifyStyleSheet(content, Settings);
            }
            else
            {
                stylesheet = minifier.MinifyStyleSheet(content);
            }

            return stylesheet;
        }

        private static MinificationResult MinifyCss(Config config, string file)
        {
            string content = File.ReadAllText(file);
            var settings = CssOptions.GetSettings(config);

            if (config.Minify.ContainsKey("enabled") && config.Minify["enabled"].ToString().Equals("false", StringComparison.OrdinalIgnoreCase))
                return null;

            var minifier = new Minifier();

            // Remove control characters which AjaxMin can't handle
            content = Regex.Replace(content, @"[\u0000-\u0009\u000B-\u000C\u000E-\u001F]", string.Empty);

            string result = minifier.MinifyStyleSheet(content, settings);
            string minFile = GetMinFileName(file);
            bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result);

            OnBeforeWritingMinFile(file, minFile, containsChanges);

            if (containsChanges)
            {
                File.WriteAllText(minFile, result, new UTF8Encoding(true));
            }

            OnAfterWritingMinFile(file, minFile, containsChanges);

            GzipFile(config, minFile, containsChanges);

            return new MinificationResult(result, null);
        }

    /// <summary>
    /// Minifies the specified CSS.
    /// </summary>
    /// <param name="resource">The CSS to minify.</param>
    /// <returns>The minified CSS, if minification was successful; otherwise, the original CSS with minification errors appended at the end.</returns>
    public string Minify(string resource)
    {
        if (String.IsNullOrEmpty(resource))
        {
            return resource;
        }

        var settings = new CssSettings
        {
            AllowEmbeddedAspNetBlocks = false
        };
        var minifier = new Minifier();
        try
        {
            resource = minifier.MinifyStyleSheet(resource, settings);
        }
        catch
        {
            var minificationErrors = String.Join(Environment.NewLine, minifier.Errors);
            resource = AppendMinificationErrors(resource, minificationErrors);

            if (mLogErrors)
            {
                CoreServices.EventLog.LogEvent("W", "Resource minification", "CssMinificationFailed", minificationErrors);
            }
        }

        return resource;
    }

        public override IEnumerable<PvcCore.PvcStream> Execute(IEnumerable<PvcCore.PvcStream> inputStreams)
        {
            var minifyStreams = inputStreams.Where(x => Regex.IsMatch(x.StreamName, @"\.(js|css)$"));
            var resultStreams = new List<PvcStream>();

            foreach (var inputStream in minifyStreams)
            {
                var fileContent = new StreamReader(inputStream).ReadToEnd();
                var minifier = new Minifier();
                var resultContent = inputStream.StreamName.EndsWith(".js") ? minifier.MinifyJavaScript(fileContent) : minifier.MinifyStyleSheet(fileContent);

                foreach (var error in minifier.ErrorList)
                {
                    Console.Error.WriteLine(error.ToString());
                }

                var dirName = Path.GetDirectoryName(inputStream.StreamName);
                var fileName = Path.GetFileNameWithoutExtension(inputStream.StreamName) + ".min" + Path.GetExtension(inputStream.StreamName);

                var resultStream = PvcUtil.StringToStream(resultContent, Path.Combine(dirName, fileName));
                resultStreams.Add(resultStream);
            }

            return inputStreams.Where(x => !minifyStreams.Any(y => y.StreamName == x.StreamName)).Concat(resultStreams);
        }

        public static string MinifyString(string extension, string content)
        {
            if (extension == ".css")
            {
                Minifier minifier = new Minifier();
                CssSettings settings = new CssSettings();
                settings.CommentMode = CssComment.None;

                if (WESettings.GetBoolean(WESettings.Keys.KeepImportantComments))
                {
                    settings.CommentMode = CssComment.Important;
                }

                return minifier.MinifyStyleSheet(content, settings);
            }
            else if (extension == ".js")
            {
                Minifier minifier = new Minifier();
                CodeSettings settings = new CodeSettings()
                {
                    EvalTreatment = EvalTreatment.MakeImmediateSafe,
                    PreserveImportantComments = WESettings.GetBoolean(WESettings.Keys.KeepImportantComments)
                };

                return minifier.MinifyJavaScript(content, settings);
            }

            return null;
        }

 /// <summary>
 /// Minifies the CSS.
 /// </summary>
 /// <param name="css">The CSS.</param>
 /// <returns></returns>
 public static String MinifyCss(String css)
 {
     if (String.IsNullOrWhiteSpace(css))
         return css;
     var min = new Minifier();
     return min.MinifyStyleSheet(css);
     //return Yahoo.Yui.Compressor.CssCompressor.Compress(css);
 }

        public string CompressContent(string content, bool removeComments)
        {
            var settings = new CssSettings();
            if(removeComments)
                settings.CommentMode = CssComment.None;

            var minifier = new Minifier();
            return minifier.MinifyStyleSheet(content, settings);
        }

 protected override string Compress(string source)
 {
     var minifier = new Minifier();
     var minified = minifier.MinifyStyleSheet(source);
     if (minifier.Errors.Count > 0)
     {
         return source;
     }
     return minified;
 }

        public override void Process(BundleContext context, BundleResponse response)
        {
            response.ContentType = ContentType.JavaScript;
            
            if (context.HttpContext.IsDebuggingEnabled)
            {
                return;
            }

            var minifier = new Minifier();
            response.Content = minifier.MinifyStyleSheet(response.Content);
        }    

        public void Write(Module module)
        {
            var minifier = new Minifier();

            textWriter.Write(
                minifier.MinifyStyleSheet(
                    string.Join(
                        "\r\n",
                        module.Resources.Select(ReadCss)
                    )
                )
            );
        }

        public static string MinifiContentToString(string content, ContentType contentType)
        {
            Minifier minifier = new Minifier();

            if (contentType == ContentType.css)
            {
                content = minifier.MinifyStyleSheet(content);
            }
            else if (contentType == ContentType.javascript)
            {
                content = minifier.MinifyJavaScript(content);
            }

            return content;
        }

        public static byte[] MinifyContent(string content, ContentType contentType)
        {
            Minifier minifier = new Minifier();

            if (contentType == ContentType.css)
            {
                content = minifier.MinifyStyleSheet(content);
            }
            else if (contentType == ContentType.javascript)
            {
                content = minifier.MinifyJavaScript(content);
            }

            return Encoding.UTF8.GetBytes(content);
        }

    private static void Minify(HttpResponse response, string file, string ext)
    {
        string content = File.ReadAllText(file);
        Minifier minifier = new Minifier();

        if (ext == ".css")
        {
            CssSettings settings = new CssSettings() { CommentMode = CssComment.None };
            response.Write(minifier.MinifyStyleSheet(content, settings));
        }
        else if (ext == ".js")
        {
            CodeSettings settings = new CodeSettings() { PreserveImportantComments = false };
            response.Write(minifier.MinifyJavaScript(content, settings));
        }
    }