Yalnızca bazı grupları Regex ile değiştirin

Aşağıdaki regex'im olduğunu varsayalım:

-(\d+)-

ve aşağıdakileri elde etmek için, C # kullanarak, Grup 1 (\d+)ile değiştirmek istiyorum AA:

-AA-

Şimdi şunu kullanarak değiştiriyorum:

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

Ama bunu gerçekten sevmiyorum, çünkü _(\d+)_bunun yerine deseni değiştirecek olursam, değiştirme dizesini _AA_de değiştirmem gerekecek ve bu KURU ilkesine aykırı.

Gibi bir şey arıyorum:

Eşleşen metni tam olarak olduğu gibi tutun, ancak Grup 1'i this textve Grup 2'yi another text... ile değiştirin.

Edit:
Bu sadece bir örnek oldu. Sadece yukarıda söylediğim şeyi yapmanın genel bir yolunu arıyorum.

Bunun için çalışması gerekir:

anything(\d+)more_text ve hayal edebileceğiniz herhangi bir desen.

Tek yapmak istediğim sadece grupları değiştirmek ve maçın geri kalanını tutmak.

Bunları tanımlamanız gerekip gerekmediğine bakılmaksızın, grup içindeki her şeyi kapsüllemek iyi bir fikir olabilir. Bu şekilde onları değiştirme dizenizde kullanabilirsiniz. Örneğin:

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

veya bir MatchEvaluator kullanarak:

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

Başka bir yol, biraz dağınık, bir gözetleme / gözetleme kullanmak olabilir:

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

Bunu ileriye ve geriye doğru kullanarak yapabilirsiniz :

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

Ayrıca buna ihtiyacım vardı ve bunun için aşağıdaki uzantı yöntemini oluşturdum:

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

Kullanımı:

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

Sonuç:

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

Deseninizi değiştirmek istemiyorsanız, eşleşen bir grubun Grup Dizini ve Uzunluk özelliklerini kullanabilirsiniz.

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;

Deseninizi değiştirmeyi gerektirmeyen başka bir güzel temiz seçenek.

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

ayrı grup değişimini elde etmek için aşağıdaki kodlamayı gözden geçirin.

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'inkine benzer, ancak birden fazla eşleşmenin yerini alan bir sürüm:

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;