แทนที่บางกลุ่มด้วย Regex

สมมติว่าฉันมี regex ต่อไปนี้:

-(\d+)-

และฉันต้องการแทนที่โดยใช้ C # กลุ่ม 1 (\d+)ด้วยAAเพื่อรับ:

-AA-

ตอนนี้ฉันกำลังแทนที่ด้วย:

var text = "example-123-example";
var pattern = @"-(\d+)-";
var replaced = Regex.Replace(text, pattern, "-AA-"); 

แต่ฉันไม่ชอบสิ่งนี้เพราะถ้าฉันเปลี่ยนรูปแบบให้ตรงกัน_(\d+)_แทนฉันจะต้องเปลี่ยนสายอักขระการแทนที่ด้วย_AA_ด้วยและสิ่งนี้ขัดกับหลักการของ DRY

ฉันกำลังมองหาสิ่งที่ชอบ:

เก็บข้อความที่ตรงกันทุกประการว่าเป็นอย่างไร แต่เปลี่ยนกลุ่ม 1 โดยthis textและกลุ่ม 2 ตามanother text...

แก้ไข:
นั่นเป็นเพียงตัวอย่าง ฉันแค่กำลังมองหาวิธีทั่วไปในการทำสิ่งที่ฉันพูดไว้ข้างต้น

มันควรจะทำงานเพื่อ:

anything(\d+)more_text และรูปแบบใด ๆ ที่คุณสามารถจินตนาการได้

สิ่งที่ฉันต้องการทำคือแทนที่เฉพาะกลุ่มและรักษาส่วนที่เหลือของการแข่งขัน

ความคิดที่ดีอาจเป็นแค็ปซูลทุกอย่างภายในกลุ่มไม่ว่าจะต้องระบุหรือไม่ก็ตาม ด้วยวิธีนี้คุณสามารถใช้มันในสตริงการแทนที่ของคุณ ตัวอย่างเช่น:

var pattern = @"(-)(\d+)(-)";
var replaced = Regex.Replace(text, pattern, "$1AA$3"); 

หรือใช้ MatchEvaluator:

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

อีกวิธีหนึ่งที่ยุ่งเล็กน้อยอาจใช้ lookbehind / lookahead:

(?<=-)(\d+)(?=-)

คุณสามารถทำได้โดยใช้lookahead และ lookbehind :

var pattern = @"(?<=-)\d+(?=-)";
var replaced = Regex.Replace(text, pattern, "AA"); 

ฉันยังต้องการสิ่งนี้และฉันได้สร้างวิธีการต่อไปนี้:

public static class RegexExtensions
{
    public static string ReplaceGroup(
        this Regex regex, string input, string groupName, string replacement)
    {
        return regex.Replace(
            input,
            m =>
            {
                var group = m.Groups[groupName];
                var sb = new StringBuilder();
                var previousCaptureEnd = 0;
                foreach (var capture in group.Captures.Cast<Capture>())
                {
                    var currentCaptureEnd =
                        capture.Index + capture.Length - m.Index;
                    var currentCaptureLength =
                        capture.Index - m.Index - previousCaptureEnd;
                    sb.Append(
                        m.Value.Substring(
                            previousCaptureEnd, currentCaptureLength));
                    sb.Append(replacement);
                    previousCaptureEnd = currentCaptureEnd;
                }
                sb.Append(m.Value.Substring(previousCaptureEnd));

                return sb.ToString();
            });
    }
}

การใช้งาน:

var input = @"[assembly: AssemblyFileVersion(""2.0.3.0"")][assembly: AssemblyFileVersion(""2.0.3.0"")]";
var regex = new Regex(@"AssemblyFileVersion\(""(?<version>(\d+\.?){4})""\)");


var result = regex.ReplaceGroup(input , "version", "1.2.3");

ผลลัพธ์:

[assembly: AssemblyFileVersion("1.2.3")][assembly: AssemblyFileVersion("1.2.3")]

หากคุณไม่ต้องการเปลี่ยนรูปแบบของคุณคุณสามารถใช้คุณสมบัติกลุ่มดัชนีและความยาวของกลุ่มที่ตรงกัน

var text = "example-123-example";
var pattern = @"-(\d+)-";
var regex = new RegEx(pattern);
var match = regex.Match(text);

var firstPart = text.Substring(0,match.Groups[1].Index);    
var secondPart = text.Substring(match.Groups[1].Index + match.Groups[1].Length);
var fullReplace = firstPart + "AA" + secondPart;

นี่เป็นอีกตัวเลือกที่ดีสะอาดที่ไม่ต้องเปลี่ยนรูปแบบของคุณ

        var text = "example-123-example";
        var pattern = @"-(\d+)-";

        var replaced = Regex.Replace(text, pattern, (_match) =>
        {
            Group group = _match.Groups[1];
            string replace = "AA";
            return String.Format("{0}{1}{2}", _match.Value.Substring(0, group.Index - _match.Index), replace, _match.Value.Substring(group.Index - _match.Index + group.Length));
        });

อ่านรหัสด้านล่างเพื่อรับการแทนที่กลุ่มแยกกัน

new_bib = Regex.Replace(new_bib, @"(?s)(\\bibitem\[[^\]]+\]\{" + pat4 + @"\})[\s\n\v]*([\\\{\}a-zA-Z\.\s\,\;\\\#\\\$\\\%\\\&\*\@\\\!\\\^+\-\\\=\\\~\\\:\\\" + dblqt + @"\\\;\\\`\\\']{20,70})", delegate(Match mts)
                    {
                           var fg = mts.Groups[0].Value.ToString(); 
                           var fs = mts.Groups[1].Value.ToString();
                           var fss = mts.Groups[2].Value.ToString();
                               fss = Regex.Replace(fss, @"[\\\{\}\\\#\\\$\\\%\\\&\*\@\\\!\\\^+\-\\\=\\\~\\\:\\\" + dblqt + @"\\\;\\\`\\\']+", "");
                           return "<augroup>" + fss + "</augroup>" + fs;
                    }, RegexOptions.IgnoreCase);

นี่คือรุ่นที่คล้ายกับ Daniel's แต่แทนที่การแข่งขันหลายนัด:

public static string ReplaceGroup(string input, string pattern, RegexOptions options, string groupName, string replacement)
{
    Match match;
    while ((match = Regex.Match(input, pattern, options)).Success)
    {
        var group = match.Groups[groupName];

        var sb = new StringBuilder();

        // Anything before the match
        if (match.Index > 0)
            sb.Append(input.Substring(0, match.Index));

        // The match itself
        var startIndex = group.Index - match.Index;
        var length = group.Length;
        var original = match.Value;
        var prior = original.Substring(0, startIndex);
        var trailing = original.Substring(startIndex + length);
        sb.Append(prior);
        sb.Append(replacement);
        sb.Append(trailing);

        // Anything after the match
        if (match.Index + match.Length < input.Length)
            sb.Append(input.Substring(match.Index + match.Length));

        input = sb.ToString();
    }

    return input;