Substitua apenas alguns grupos por Regex

Vamos supor que eu tenha o seguinte regex:

-(\d+)- 

e eu quero replace, usando C #, o Grupo 1 (\d+) com AA , para obter:

 -AA- 

Agora estou substituindo-o usando:

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

Mas eu realmente não gosto disso, porque se eu mudar o padrão para combinar _(\d+)_ , eu terei que alterar a string de substituição por _AA_ também, e isso é contra o princípio DRY.

Eu estou procurando por algo como:

Mantenha o texto correspondente exatamente como está, mas altere o Grupo 1 por this text e o Grupo 2 por another text

Editar:
Aquilo foi apenas um exemplo. Eu só estou procurando uma maneira genérica de fazer o que eu disse acima.

Deve funcionar para:

anything(\d+)more_text e qualquer padrão que você possa imaginar.

Tudo o que quero fazer é replace apenas grupos e manter o restante da partida.

Uma boa ideia poderia ser encapsular tudo dentro dos grupos, não importando se é necessário identificá-los ou não. Dessa forma, você pode usá-los em sua string de substituição. Por exemplo:

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

ou usando um MatchEvaluator:

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

Outra maneira, um pouco confusa, poderia estar usando um lookbehind / lookahead:

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

Você pode fazer isso usando lookahead e lookbehind :

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

Eu também precisava disso e criei o seguinte método de extensão:

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

Uso:

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

Resultado:

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

Se você não quiser alterar seu padrão, poderá usar as propriedades Índice de Grupo e Comprimento de um grupo correspondente.

 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; 

Aqui está outra opção legal que não requer mudanças no padrão.

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

percorrer a codificação abaixo para obter a substituição do grupo separado.

 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 "" + fss + "" + fs; }, RegexOptions.IgnoreCase);