Vous souhaitez coder le texte pendant l'appel Regex.Replace

Question

J'ai un appel regex que j'ai besoin d'aide.

Je n'ai pas posté mon regex, car ce n'est pas pertinent ici. Ce que je veux être en mesure de faire est, pendant le remplacement, je veux également modifier la partie $ {test} en faisant un Html.Encode sur le texte entier qui effectue la regex.

Fondamentalement, envelopper le texte entier qui est dans la gamme de l'expression régulière avec la balise en gras, mais aussi Html.Encode le texte entre la balise en gras.

RegexOptions regexOptions = RegexOptions.Compiled | RegexOptions.IgnoreCase; 
text = Regex.Replace(text, regexBold, @"<b>${text}</b>", regexOptions); 

Answer 1

Voici une implémentation de ceci que j'ai utilisée pour sélectionner des chaînes spéciales remplacer du contenu et les localiser.

 protected string FindAndTranslateIn(string content) 
     { 
      return Regex.Replace(content, @"\{\^(.+?);(.+?)?}", new MatchEvaluator(TranslateHandler), RegexOptions.IgnoreCase); 
     } 

public string TranslateHandler(Match m) 
{ 
    if (m.Success) 
    { 
     string key = m.Groups[1].Value; 
     key = FindAndTranslateIn(key); 
     string def = string.Empty; 
     if (m.Groups.Count > 2) 
     { 
      def = m.Groups[2].Value; 
      if(def.Length > 1) 
      { 
       def = FindAndTranslateIn(def); 
      } 
     } 

     if (group == null) 
     { 
      return Translate(key, def); 
     } 
     else 
     { 
      return Translate(key, group, def); 
     } 
    } 
    return string.Empty; 
} 

du délégué évaluateur de match, vous revenez tout ce que vous voulez remplacer, alors où je les retours que vous auriez les balises gras et un appel encode, le mien prend également en charge la récursivité, donc un peu plus compliqué pour vos besoins, mais vous peut juste réduire l'exemple pour vos besoins. Cela équivaut à effectuer une itération sur la collection de correspondances et à effectuer des parties du travail de remplacement des méthodes. Il vous suffit d'économiser du code, et vous pouvez utiliser un délégué shmancy.

Answer 2

Ne pas utiliser Regex.Replace dans ce cas ... .. utilisation

foreach(Match in Regex.Matches(...)) 
{ 
    //do your stuff here 
} 

Answer 3

Si vous faites un Regex.Match, le groupe objets correspondent résultant à l'indice 0e, est le sous-ensemble de l'intput qui correspond à l'expression rationnelle.

Vous pouvez l'utiliser pour assembler les étiquettes en gras et les encoder ici.

Answer 4

Pouvez-vous remplir le code à l'intérieur {} pour ajouter la balise en gras et encoder le texte? Je suis confus quant à la façon d'appliquer les modifications à l'ensemble du bloc de texte ET remplacer la section dans la variable de texte à la fin.

Answer 5

Il y a une manière incroyablement facile de faire ceci (dans .net). Son appelé un MatchEvaluator et il vous permet de faire toutes sortes de trouver et remplacer cool. Essentiellement, vous ne faites qu'alimenter la méthode Regex.Replace, le nom de la méthode d'une méthode qui renvoie une chaîne et accepte un objet Match comme seul paramètre. Faites ce qui est logique pour votre correspondance particulière (encodage html) et la chaîne que vous renvoyez remplacera le texte entier de la correspondance dans la chaîne d'entrée. Exemple: Disons que vous vouliez trouver tous les endroits où il y a deux nombres ajoutés (dans le texte) et vous voulez remplacer l'expression par le nombre réel. Vous ne pouvez pas le faire avec une approche regex stricte, mais vous pouvez le faire lorsque vous lancez un MatchEvaluator, cela devient facile.

public void Stuff() 
{ 
    string pattern = @"(?<firstNumber>\d+)\s*(?<operator>[*+-/])\s*(?<secondNumber>\d+)"; 
    string input = "something something 123 + 456 blah blah 100 - 55"; 
    string output = Regex.Replace(input, pattern, MatchMath); 
    //output will be "something something 579 blah blah 45" 
} 

private static string MatchMath(Match match) 
{ 
    try 
    { 
     double first = double.Parse(match.Groups["firstNumber"].Value); 
     double second = double.Parse(match.Groups["secondNumber"].Value); 
     switch (match.Groups["operator"].Value) 
     { 
      case "*": 
       return (first * second).ToString(); 
      case "+": 
       return (first + second).ToString(); 
      case "-": 
       return (first - second).ToString(); 
      case "/": 
       return (first/second).ToString(); 
     } 
    } 
    catch { } 
    return "NaN"; 
} 

En savoir plus sur http://msdn.microsoft.com/en-us/library/system.text.regularexpressions.matchevaluator.aspx