क्या एक मैच कोलेक्शन इसे फिर से चलाने की कोशिश करते समय प्रोग्राम को लटका सकता है?

Question

मेरे पास एक कोड उदाहरण है जहां फ़ोरैच के साथ इसका उपयोग करने का प्रयास करते समय एक मैचकोलेक्शन प्रोग्राम को लटका लगता है।

मैं एक वर्ग CSSParser का उपयोग कर सीएसएस को पार्स कर रहा हूँ:

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

और इसे इस तरह इनपुट के साथ ठीक काम करता है:

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

लेकिन जब मैं यह एक सीएसएस स्ट्रिंग कोई विशेषताओं वाली के साथ चलाएँ:

 [TestMethod] 
     public void TestParseNoAttributesStyle() 
     { 
      const string css = @" 
#submenu-container 
{ 
} 
"; 

      var parser = new CSSParser(css); 

      Assert.IsFalse(parser.LookupValues("#submenu-container").Any()); 
     } 

प्रोग्राम CSSParser में इस पंक्ति पर लटक रहा है:

foreach (Match item in matches) 

डीबगर वर्तमान में निष्पादित लाइन को चिह्नित करने से रोकता है, लूप ब्लॉक स्वयं कभी नहीं पहुंचता है।

MatchCollection मेरे प्रोग्राम को क्यों लटक रहा है?

पूर्णता के लिए:

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

Answer 1

आपका Regex बस अक्षम और जल सीपीयू है। आप इसकी पुष्टि कर सकते हैं ए) इस्तेमाल किए गए CPU समय को देखते हुए और बी) डीबगर को बार-बार रोकना और स्टैक को देखना (रेगेक्स इंजन के आंतों में होगा)।

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

लिए:

Answer 2

मैं से regexp बदल

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

और निष्पादन समय 1 एमएस करने के लिए 22 सेकंड से नीचे चला गया।

Answer 3

जहाँ तक मैं कह सकता हूं .net एक शाश्वत पाश में जाता है क्योंकि यह आपके द्वारा प्राप्त किए गए रेगेक्स के साथ अलग-अलग दृष्टिकोणों की कोशिश करता है (समूह पैटर्न एक) - मेरा मानना ​​है कि यह कहीं गलती करता है। मैंने इस रेगेक्स पर एक नज़र डाली है और जहां तक ​​मैं कह सकता हूं कि आप आसानी से \s* में से दो को हटा सकते हैं, अर्थात् जो नकारात्मक क्रम से पहले [^,{]+ और [^}:]+ से पहले आते हैं, क्योंकि वे पहले से ही रिक्त स्थान पर कब्जा कर लेते हैं।

तो वह है, बजाय:

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

मैं होगा:

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

अब इस regex भाव है, इसलिए मुझे की संभावना की अनदेखी हो रही है कुछ नहीं बल्कि बड़े हैं। इसके अलावा मेरा मानना ​​है कि इसके नामित कैप्चर समूहों में से कुछ में शायद अतिरिक्त रिक्त स्थान भी हैं (लेकिन ऐसा लगता है कि आप उन्हें वैसे भी ट्रिम करते हैं)।

आशा है कि यह उपयोग योग्य है। हालांकि इसमें अभी भी कुछ समय लगता है, यह आपके द्वारा दिए गए उदाहरण के साथ काम करता है।