Remplacer le groupe nommé dans la regex par la valeur

Question

Je souhaite utiliser l'expression régulière de la même manière que la chaîne.Format. Je vais vous expliquer

J'ai:

string pattern = "^(?<PREFIX>abc_)(?<ID>[0-9])+(?<POSTFIX>_def)$"; 
string input = "abc_123_def"; 
Regex regex = new Regex(pattern, RegexOptions.IgnoreCase); 
string replacement = "456"; 
Console.WriteLine(regex.Replace(input, string.Format("${{PREFIX}}{0}${{POSTFIX}}", replacement))); 

Cela fonctionne, mais je dois fournir "entrée" à Regex.Replace. Je ne veux pas ça. Je veux utiliser un motif pour faire correspondre mais aussi pour créer des chaînes de la même manière qu'avec un format de chaîne, en remplaçant le groupe nommé "ID" par une valeur. Est-ce possible?

Je cherche quelque chose comme:

string pattern = "^(?<PREFIX>abc_)(?<ID>[0-9])+(?<POSTFIX>_def)$"; 
string result = ReplaceWithFormat(pattern, "ID", 999); 

Résultat contiendra "abc_999_def". Comment accomplir cela?

Answer 1

Non, il n'est pas possible d'utiliser une expression régulière sans fournir d'entrée. Il doit avoir quelque chose à travailler, le modèle ne peut pas ajouter de données au résultat, tout doit provenir de l'entrée ou du remplacement.

intead d'utiliser String.Format, vous pouvez utiliser un coup d'oeil derrière et un regard vers l'avenir pour spécifier la partie entre « abc_ » et « _def », et de le remplacer:

string result = Regex.Replace(input, @"(?<=abc_)\d+(?=_def)", "999"); 

Answer 2

Oui, il est possible :

public static class RegexExtensions 
{ 
    public static string Replace(this string input, Regex regex, string groupName, string replacement) 
    { 
     return regex.Replace(input, m => 
     { 
      return ReplaceNamedGroup(input, groupName, replacement, m); 
     }); 
    } 

    private static string ReplaceNamedGroup(string input, string groupName, string replacement, Match m) 
    { 
     string capture = m.Value; 
     capture = capture.Remove(m.Groups[groupName].Index - m.Index, m.Groups[groupName].Length); 
     capture = capture.Insert(m.Groups[groupName].Index - m.Index, replacement); 
     return capture; 
    } 
} 

Utilisation:

Regex regex = new Regex("^(?<PREFIX>abc_)(?<ID>[0-9]+)(?<POSTFIX>_def)$"); 

string oldValue = "abc_123_def"; 
var result = oldValue.Replace(regex, "ID", "456"); 

Le résultat est: abc_456_def

Answer 3

Il y avait un problème dans la réponse user1817787 et j'ai dû apporter une modification à la fonction ReplaceNamedGroup comme suit.

private static string ReplaceNamedGroup(string input, string groupName, string replacement, Match m) 
{ 
    string capture = m.Value; 
    capture = capture.Remove(m.Groups[groupName].Index - m.Index, m.Groups[groupName].Length); 
    capture = capture.Insert(m.Groups[groupName].Index - m.Index, replacement); 
    return capture; 
} 

Answer 4

Une autre version modifiée de la méthode originale par @ user1817787, celui-ci prend en charge plusieurs instances du groupe nommé (comprend également similaire à celui fixe @Justin affiché (renvoie le résultat en utilisant {match.Index, match de .length} au lieu de {0, input.Length})):

public static string ReplaceNamedGroup(
    string input, string groupName, string replacement, Match match) 
{ 
    var sb = new StringBuilder(input); 
    var matchStart = match.Index; 
    var matchLength = match.Length; 

    var captures = match.Groups[groupName].Captures.OfType<Capture>() 
     .OrderByDescending(c => c.Index); 

    foreach (var capt in captures) 
    { 
     if (capt == null) 
      continue; 

     matchLength += replacement.Length - capt.Length; 

     sb.Remove(capt.Index, capt.Length); 
     sb.Insert(capt.Index, replacement); 
    } 

    var end = matchStart + matchLength; 
    sb.Remove(end, sb.Length - end); 
    sb.Remove(0, matchStart); 

    return sb.ToString(); 
} 

Answer 5

La solution simple est de se référer aux groupes appariés en remplacement. Donc, le préfixe est $1 et Postfix est $3.

J'ai ai pas testé le code ci-dessous, mais devrait fonctionner semblable à un regEx j'ai écrit récemment:

string pattern = "^(?<PREFIX>abc_)(?<ID>[0-9])+(?<POSTFIX>_def)$"; 
string input = "abc_123_def"; 
Regex regex = new Regex(pattern, RegexOptions.IgnoreCase); 
string replacement = String.Format("$1{0}$3", "456"); 
Console.WriteLine(regex.Replace(input, string.Format("${{PREFIX}}{0}${{POSTFIX}}", replacement))); 

Answer 6

Je raccourcies ReplaceNamedGroup, en soutenant plusieurs captures.

private static string ReplaceNamedGroup(string input, string groupName, string replacement, Match m) 
{ 
    string result = m.Value; 
    foreach (Capture cap in m.Groups[groupName]?.Captures) 
    { 
    result = result.Remove(cap.Index - m.Index, cap.Length); 
    result = result.Insert(cap.Index - m.Index, replacement); 
    } 
return result; 
} 

Answer 7

Vous devriez consulter la documentation de RegEx remplacer here

J'ai créé ce pour remplacer un groupe nommé. Je ne peux pas utiliser la solution de cette boucle sur tous les noms de groupes car j'ai des cas où toutes les expressions ne sont pas groupées.

public static string ReplaceNamedGroup(this Regex regex, string input, string namedGroup, string value) 
    { 
     var replacement = Regex.Replace(regex.ToString(), 
      @"((?<GroupPrefix>\(\?)\<(?<GroupName>\w*)\>(?<Eval>.[^\)]+)(?<GroupPostfix>\)))", 
      @"${${GroupName}}").TrimStart('^').TrimEnd('$'); 
     replacement = replacement.Replace("${" + namedGroup + "}", value); 
     return Regex.Replace(input, regex.ToString(), replacement); 
    }