स्ट्रिंग सरणी के लिए एक मैचकॉलिनेशन परिवर्तित करना

Question 1

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

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)एक अपवाद फेंकता है:

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

Question 2

प्रयत्न:

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

Question 3

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

यह ध्यान देने योग्य है, हालांकि जगह है कि Cast<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

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

Question 4

मैंने ठीक वही बेंचमार्क चलाया जो एलेक्स ने पोस्ट किया है और पाया है कि कभी 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

Question 5

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

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

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

Question 6

निम्नलिखित कोड पर विचार करें ...

var emailAddress = "joe@sad.com; joe@happy.com; joe@elated.com";
List<string> emails = new List<string>();
emails = Regex.Matches(emailAddress, @"([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})")
                .Cast<Match>()
                .Select(m => m.Groups[0].Value)
                .ToList();