Kann eine MatchCollection das Programm beim Versuch, es zu iterieren, hängen?

Question

Ich habe ein Codebeispiel, wo eine MatchCollection das Programm zu hängen scheint, wenn es versucht, es mit Foreach zu verwenden.

ich css bin Parsen eine Klasse CSSParser mit:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text.RegularExpressions; 
using Helpers.Extensions; 

namespace Helpers.Utils 
{ 
    public class CSSParser 
    { 
     private readonly Dictionary<string, Dictionary<string, string>> 
      _dict = new Dictionary<string, Dictionary<string, string>>(); 

     private const string SelectorKey = "selector"; 
     private const string NameKey = "name"; 
     private const string ValueKey = "value"; 

     private const string GroupsPattern 
      = @"(?<selector>(?:(?:[^,{]+)\s*,?\s*)+)\{(?:(?<name>[^}:]+)\s*:\s*(?<value>[^};]+);?\s*)*\}"; 

     private const string CommentsPattern 
      = @"(?<!"")\/\*.+?\*\/(?!"")"; 

     private readonly Regex _pattern 
      = new Regex(GroupsPattern, RegexOptions.IgnoreCase | RegexOptions.Multiline); 

     public CSSParser(string cssString) 
     { 
      var noCommentsString = Regex.Replace(cssString, CommentsPattern, ""); 
      var matches = _pattern.Matches(noCommentsString); 

      foreach (Match item in matches) 
      { 
       var selector = item.Groups[SelectorKey].Captures[0].Value.Trim(); 

       var selectorParts = selector.Split(',').Select(s=>s.Trim()); 
       foreach(var part in selectorParts) 
       { 
        if (!_dict.ContainsKey(part)) 
         _dict[part] = new Dictionary<string, string>(); 
       } 

       var classNameCaptures = item.Groups[NameKey].Captures; 
       var valueCaptures = item.Groups[ValueKey].Captures; 

       var count = item.Groups[NameKey].Captures.Count; 

       for (var i = 0; i < count; i++) 
       { 
        var className = classNameCaptures[i].Value.TrimIfNotNull(); 
        var value = valueCaptures[i].Value.TrimIfNotNull(); 

        foreach(var part in selectorParts) 
        { 
         _dict[part][className] = value; 
        } 
       } 
      } 
     } 

     public IEnumerable<KeyValuePair<string,string>> LookupValues(string selector) 
     { 
      IEnumerable<KeyValuePair<string,string>> result 
       = new KeyValuePair<string,string>[]{}; 
      if (_dict.ContainsKey(selector)) 
      { 
       var subdict = _dict[selector]; 

       result = subdict.ToList(); 
      } 

      return result; 
     } 

     public string LookupValue(string selector, string style) 
     { 
      string result = null; 
      if (_dict.ContainsKey(selector)) 
      { 
       var subdict = _dict[selector]; 

       if (subdict.ContainsKey(style)) 
        result = subdict[style]; 
      } 

      return result; 
     } 
    } 
} 

und es funktioniert gut mit Eingabe wie folgt aus:

 [TestMethod] 
     public void TestParseMultipleElementNames() 
     { 
      const string css = @"h1, h2, h3, h4, h5, h6 
{ 
    font-family: Georgia, 'Times New Roman', serif; 
    color: #006633; 
    line-height: 1.2em; 
    font-weight: normal; 
} 
"; 

      var parser = new CSSParser(css); 

      Assert.AreEqual("normal", parser.LookupValue("h4", "font-weight")); 
     } 

aber wenn ich laufe es mit einem CSS-String keine Attribute enthält:

Das Programm hängt an dieser Zeile in CSSParser:

Der Debugger stoppt die Markierung der aktuell ausgeführten Zeile, der Schleifenblock selbst wird nie erreicht.

Warum hängt die MatchCollection mein Programm?

Der Vollständigkeit halber:

namespace Helpers.Extensions 
{ 
    public static class StringExtension 
    { 
    public static string TrimIfNotNull(this string input) 
    { 
     return input != null ? input.Trim() : null; 
    } 
    } 
} 

Answer 1

Ihre Regex ist nur ineffizient und Brennen CPU. Sie können dies bestätigen, indem Sie a) die verwendete CPU-Zeit betrachten und b) den Debugger wiederholt pausieren und auf den Stack schauen (er wird sich im Inneren der Regex-Engine befinden).

Answer 2

änderte ich die regexp aus:

private const string GroupsPattern 
    = @"(?<selector>(?:(?:[^,{]+)\s*,?\s*)+)\{(?:(?<name>[^}:]+)\s*:\s*(?<value>[^};]+);?\s*)*\}"; 

zu:

private const string GroupsPattern 
    = @"(?<selector>(?:(?:[^,{]+)\s*,?\s*)+)\{\s*(?:(?<name>[^}:\s]+)\s*:\s*(?<value>[^};]+);?\s*)*\}"; 

und die Ausführungszeit ging von 22 Sekunden bis 1 ms.

Answer 3

Soweit ich das beurteilen kann .net geht in eine ewige Schleife, weil es versucht verschiedene Ansätze mit der Regex Sie haben (die GroupsPattern eins) - ich glaube, es macht einen Fehler irgendwo. Ich habe mir diesen Regex angeschaut und soweit ich das beurteilen kann, können Sie leicht zwei der \s* entfernen, nämlich diejenigen, die vor den Negationsgruppen [^,{]+ und [^}:]+ stehen, da sie bereits Leerzeichen erfassen.

Also das heißt, statt:

private const string GroupsPattern = @"(?<selector>(?:(?:[^,{]+)\s*,?\s*)+)\{(?:(?<name>[^}:]+)\s*:\s*(?<value>[^};]+);?\s*)*\}"; 

hätte ich:

private const string GroupsPattern = @"(?<selector>(?:(?:[^,{]+),?\s*)+)\{(?:(?<name>[^}:]+):\s*(?<value>[^};]+);?\s*)*\}"; 

Nun ist diese Regex Ausdrücke ist, so dass die Chancen von mir übersehen haben etwas ziemlich groß. Außerdem glaube ich, dass dies auch dazu führt, dass einige der genannten Capture-Gruppen möglicherweise zusätzliche Leerzeichen enthalten (aber es scheint, dass Sie sie trotzdem schneiden).

Ich hoffe, es ist verwendbar. Obwohl es noch einige Zeit dauert, funktioniert es mit dem Beispiel, das Sie gegeben haben.