सी # में रेगेक्स - मैं मैच में केवल एक विशिष्ट समूह को कैसे प्रतिस्थापित करता हूं?

Question

मैं सी # रेगेक्स का उपयोग कर एक पाठ पार्स कर रहा हूं। मैं प्रत्येक मैच के लिए केवल एक विशिष्ट समूह को प्रतिस्थापित करना चाहता हूं। यहाँ कैसे मैं इसे कर रहा हूँ:

void Replace(){ 
    string newText = Regex.Replace(File.ReadAllText(sourceFile), myRegex, Matcher, RegexOptions.Singleline); 
    //....... 
} 

void string Matcher(Match m){ 
    // how do I replace m.Groups[2] with "replacedText"? 
    return ""; // I want to return m.Value with replaced m.Group[2] 
} 

Answer 1

यह करना चाहिए:

string Matcher(Match m) 
{ 
    if (m.Groups.Count < 3) 
    { 
     return m.Value; 
    } 

    return string.Join("", m.Groups 
          .OfType<Group>() //for LINQ 
          .Select((g, i) => i == 2 ? "replacedText" : g.Value) 
          .Skip(1) //for Groups[0] 
          .ToArray()); 
} 

उदाहरण: http://rextester.com/DLGVPA38953

संपादित करें: हालांकि ऊपर लिखा के रूप में अपने प्रश्न का उत्तर है, आप पा सकते शून्य चौड़ाई lookarounds अपने वास्तविक के लिए आसान परिदृश्य:

Regex.Replace(input, @"(?<=e)l+(?=o)", replacement) 

उदाहरण: http://rextester.com/SOWWS24307

012,

Answer 2

आप MatchEvaluator उपयोग कर सकते हैं: यह कोशिश करो।

var replaced = Regex.Replace(text, pattern, m => m.Groups[1] + "AA" + m.Groups[3]); 

मैंने पाया इस से संबंधित stackoverflow में एक पोस्ट: घड़ी This

Answer 3

कैसे इस बारे में?

static string Matcher(Match m) 
    { 
     var group = m.Groups[2]; 
     var startIndex = group.Index - m.Index; 
     var length = group.Length; 
     var original = m.Value; 
     var prior = original.Substring(0, startIndex); 
     var trailing = original.Substring(startIndex + length); 
     return string.Concat(prior, "replacedText", trailing); 
    } 

Answer 4

Regex.Replace हमेशा सब कुछ प्रदान की regex मिलान किया है की जगह लेगा।

आप दो संभावनाएं हैं:

1. मैच केवल क्या आप को बदलने के लिए

   या

2. सम्मिलित मूल स्ट्रिंग जो मिलान कर दिया गया है के कुछ हिस्सों, लेकिन रखा जाना चाहिए चाहते हैं, कैप्चरिंग समूहों का उपयोग करके प्रतिस्थापन स्ट्रिंग में।

आपने अपने प्रश्न का उत्तर देने के लिए पर्याप्त जानकारी प्रदान नहीं की है। जैसे क्या आपको वास्तव में MatchEvaluator की आवश्यकता है? यह केवल तभी जरूरी है, यदि आप प्रत्येक मैच के लिए एक व्यक्तिगत प्रतिस्थापन स्ट्रिंग प्रदान करना चाहते हैं।

Answer 5

private string ReplaceText(string originalText) 
    { 
     string replacedText = null; 

     Regex regEx = new Regex("[your expression here]"); 

     Match match = regEx.Match(originalText); 

     if (match.Success) 
     { 
      Group matchGroup = match.Groups[2]; 

      //[first part of original string] + [replaced text] + [last part of original string] 
      replacedText = 
       $"{originalText.Substring(0, matchGroup.Index)}[Your replaced string here]{originalText.Substring(matchGroup.Index + matchGroup.Length)}"; 

     } 
     else 
      replacedText = originalText; 

     return replacedText; 
    } 

Answer 6

नीचे कोड एक मैच लेगा और समूहव्यू संग्रह पर आधारित एक प्रतिस्थापन स्ट्रिंग का निर्माण करेगा। यह संग्रह समूह के सूचकांक और पाठ को इसके मान को प्रतिस्थापित करने के लिए निर्दिष्ट करता है।

अन्य समाधानों के विपरीत, समूह में केवल मिलान के पूरे भाग की आवश्यकता नहीं होती है, जो आप समूहों में होना चाहते हैं।

public static string ReplaceGroups(Match match, Dictionary<int, string> groupValues) 
{ 
    StringBuilder result = new StringBuilder(); 

    int currentIndex = 0; 
    int offset = 0; 

    foreach (KeyValuePair<int, string> replaceGroup in groupValues.OrderBy(x => x.Key)) 
    { 
     Group group = match.Groups[replaceGroup.Key]; 

     if (currentIndex < group.Index) 
     { 
      result.Append(match.Value.Substring(currentIndex, group.Index - match.Index - currentIndex)); 
     } 

     result.Append(replaceGroup.Value); 

     offset += replaceGroup.Value.Length - group.Length; 
     currentIndex = group.Index - match.Index + group.Length; 
    } 

    return result.ToString(); 
}