c# - एक स्ट्रिंग सरणी में एक मिलान को परिवर्तित करना




arrays regex (4)

कोई भी सामान्य MatchCollection नहीं होने के कारण MatchCollection की परेशानी से निपटने के लिए इस विस्तार विधि का उपयोग कर सकता है। यह नहीं कि यह एक बड़ा सौदा है, लेकिन यह लगभग निश्चित रूप से OfType या Cast से अधिक प्रदर्शनकारी है, क्योंकि यह सिर्फ गणना कर रहा है, जो दोनों को भी करना है।

(साइड नोट: मुझे आश्चर्य है कि क्या .NET टीम के लिए MatchCollection को भविष्य में MatchCollection जेनेरिक संस्करणों और MatchCollection उत्तराधिकारी बनाने के लिए संभव होगा? फिर हमें LINQ ट्रांसफ़ॉर्म उपलब्ध होने के लिए इस अतिरिक्त चरण की आवश्यकता नहीं होगी)

    public static IEnumerable<Match> ToEnumerable(this MatchCollection mc)
    {
        if (mc != null) {
            foreach (Match m in mc)
                yield return m;
        }
    }

https://code.i-harness.com

क्या एक मिलान को एक स्ट्रिंग सरणी में परिवर्तित करने के लिए इससे बेहतर तरीका है?

MatchCollection mc = Regex.Matches(strText, @"\b[A-Za-z-']+\b");
string[] strArray = new string[mc.Count];
for (int i = 0; i < mc.Count;i++ )
{
    strArray[i] = mc[i].Groups[0].Value;
}

पीएस: mc.CopyTo(strArray,0) एक अपवाद फेंकता है:

स्रोत सरणी में कम से कम एक तत्व गंतव्य सरणी प्रकार पर नहीं डाला जा सका।


डेव बिश का जवाब अच्छा है और ठीक से काम करता है।

यह ध्यान देने योग्य है यद्यपि Cast<Match>() को OfType<Match>() साथ OfType<Match>() चीजों को गति देगा।

कोड बन गया:

var arr = Regex.Matches(strText, @"\b[A-Za-z-']+\b")
    .OfType<Match>()
    .Select(m => m.Groups[0].Value)
    .ToArray();

नतीजा बिल्कुल वही है (और ओपी के मुद्दे को सटीक तरीके से संबोधित करता है) लेकिन भारी तारों के लिए यह तेज़ है।

टेस्ट कोड:

// put it in a console application
static void Test()
{
    Stopwatch sw = new Stopwatch();
    StringBuilder sb = new StringBuilder();
    string strText = "this will become a very long string after my code has done appending it to the stringbuilder ";

    Enumerable.Range(1, 100000).ToList().ForEach(i => sb.Append(strText));
    strText = sb.ToString();

    sw.Start();
    var arr = Regex.Matches(strText, @"\b[A-Za-z-']+\b")
              .OfType<Match>()
              .Select(m => m.Groups[0].Value)
              .ToArray();
    sw.Stop();

    Console.WriteLine("OfType: " + sw.ElapsedMilliseconds.ToString());
    sw.Reset();

    sw.Start();
    var arr2 = Regex.Matches(strText, @"\b[A-Za-z-']+\b")
              .Cast<Match>()
              .Select(m => m.Groups[0].Value)
              .ToArray();
    sw.Stop();
    Console.WriteLine("Cast: " + sw.ElapsedMilliseconds.ToString());
}

आउटपुट निम्नानुसार है:

OfType: 6540
Cast: 8743

बहुत लंबे तारों के लिए कास्ट () धीमा है।


प्रयत्न:

var arr = Regex.Matches(strText, @"\b[A-Za-z-']+\b")
    .Cast<Match>()
    .Select(m => m.Value)
    .ToArray();

मैंने सटीक उसी बेंचमार्क को चलाया कि एलेक्स ने पोस्ट किया है और पाया है कि कभी-कभी Cast तेजी से होता था और कभी-कभी OfType तेज था, लेकिन दोनों के बीच का अंतर नगण्य था। हालांकि, बदसूरत होने पर, लूप के लिए दो अन्य दोनों की तुलना में लगातार तेज़ होता है।

Stopwatch sw = new Stopwatch();
StringBuilder sb = new StringBuilder();
string strText = "this will become a very long string after my code has done appending it to the stringbuilder ";
Enumerable.Range(1, 100000).ToList().ForEach(i => sb.Append(strText));
strText = sb.ToString();

//First two benchmarks

sw.Start();
MatchCollection mc = Regex.Matches(strText, @"\b[A-Za-z-']+\b");
var matches = new string[mc.Count];
for (int i = 0; i < matches.Length; i++)
{
    matches[i] = mc[i].ToString();
}
sw.Stop();

परिणाम:

OfType: 3462
Cast: 3499
For: 2650




regex