Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Regex.Escape, méthode (String)

 

Échappe un ensemble minimal de caractères (\, *, +, ?, |, {, [, (,), ^, $,., # et espace blanc) en les remplaçant par leur code d'échappement.Cela indique au moteur d'expressions régulières qu'il doit interpréter ces caractères littéralement, et non comme des métacaractères.

Espace de noms:   System.Text.RegularExpressions
Assembly:  System (dans System.dll)

public static string Escape(
	string str
)

Paramètres

str

Chaîne d'entrée qui contient le texte à convertir.

Valeur de retour

Type: System.String

Chaîne de caractères dont les métacaractères sont remplacés par leurs codes d'échappement.

Exception Condition
ArgumentNullException

str a la valeur null.

EscapeConvertit une chaîne afin que le moteur des expressions régulières interprète tous les métacaractères qu'elle peut contenir en tant que caractères littéraux.Par exemple, considérez une expression régulière est conçue pour extraire des commentaires sont délimités par des crochets ouvrants et fermants ([et]) à partir du texte.Dans l'exemple suivant, l'expression régulière « [(.*?)] "est interprétée comme une classe de caractères.Au lieu de la mise en correspondance les commentaires incorporés dans le texte d'entrée, l'expression régulière correspond à chaque ouverture ou une parenthèse fermante, un période, un astérisque ou un point d'interrogation.

string pattern = "[(.*?)]"; 
string input = "The animal [what kind?] was visible [by whom?] from the window.";

MatchCollection matches = Regex.Matches(input, pattern);
int commentNumber = 0;
Console.WriteLine("{0} produces the following matches:", pattern);
foreach (Match match in matches)
   Console.WriteLine("   {0}: {1}", ++commentNumber, match.Value);  

// This example displays the following output:
//       [(.*?)] produces the following matches:
//          1: ?
//          2: ?
//          3: .

Toutefois, si le crochet ouvrant est échappé en le passant à la Escape méthode, l'expression régulière parvient à faire correspondre les commentaires incorporés dans la chaîne d'entrée.L'exemple suivant illustre ce comportement.

string pattern = Regex.Escape("[") + "(.*?)]"; 
string input = "The animal [what kind?] was visible [by whom?] from the window.";

MatchCollection matches = Regex.Matches(input, pattern);
int commentNumber = 0;
Console.WriteLine("{0} produces the following matches:", pattern);
foreach (Match match in matches)
   Console.WriteLine("   {0}: {1}", ++commentNumber, match.Value);  

// This example displays the following output:
//       \[(.*?)] produces the following matches:
//          1: [what kind?]
//          2: [by whom?]

Dans une expression régulière est définie à l'aide de texte statique, les caractères qui seront interprétés littéralement, et non comme des métacaractères peuvent être évitées en le faisant précéder par un symbole de barre oblique inverse (\), ainsi qu'en appelant le Escape (méthode).Dans une expression régulière est définie dynamiquement à l'aide de caractères qui ne sont pas connus au moment du design, appelant le Escape méthode est particulièrement important de s'assurer que le moteur des expressions régulières interprète les différents caractères comme des littéraux plutôt que comme des métacaractères.

System_CAPS_noteRemarque

Si un modèle d'expression régulière inclut le signe dièse (#) ou des caractères d'espace blanc littéraux, ils doivent être échappés si le texte d'entrée est analysé avec le RegexOptions.IgnorePatternWhitespace option est activée.

Bien que le Escape méthode s'échappe du crochet gauche ([]) et l'accolade ouvrante ({}), elle n'échappe pas leurs caractères de fermeture correspondants (] et}).Dans la plupart des cas, cet échappement n'est pas nécessaire.Si une accolade ou un crochet fermant n'est pas précédée par son caractère ouvrant correspondant, le moteur des expressions régulières l'interprète littéralement.Si une accolade ou un crochet ouvrant est interprétée comme un métacaractère, le moteur des expressions régulières interprète le premier comme caractère fermant correspondant un métacaractère.Si cela n'est pas le comportement souhaité, l'accolade ou le crochet fermant doit être d'échappement en ajoutant explicitement le caractère barre oblique inverse (\).Pour obtenir une illustration, consultez la section exemple.

L'exemple suivant extrait les commentaires de texte.Il suppose que les commentaires sont délimités par un symbole de commentaire begin et un symbole de commentaire de fin est sélectionné par l'utilisateur.Les symboles de commentaire devant être interprétés littéralement, ils sont passés à la Escape pour s'assurer qu'ils ne peuvent pas être mal interprétés comme des métacaractères.En outre, l'exemple vérifie explicitement si le symbole de fin de commentaire entré par l'utilisateur est une accolade (}) ou un crochet fermant (]).S'il est, une barre oblique inverse (\) est ajoutée à l'accolade ou afin qu'il soit interprété littéralement.Notez que l'exemple utilise également la Match.Groups collection pour afficher le commentaire uniquement, plutôt que le commentaire et ses symboles ouvrant et fermant.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      ConsoleKeyInfo keyEntered;
      char beginComment, endComment;
      Console.Write("Enter begin comment symbol: ");
      keyEntered = Console.ReadKey();
      beginComment = keyEntered.KeyChar;
      Console.WriteLine();

      Console.Write("Enter end comment symbol: ");
      keyEntered = Console.ReadKey();
      endComment = keyEntered.KeyChar;
      Console.WriteLine();

      string input = "Text [comment comment comment] more text [comment]";
      string pattern;
      pattern = Regex.Escape(beginComment.ToString()) + @"(.*?)";
      string endPattern = Regex.Escape(endComment.ToString());
      if (endComment == ']' || endComment == '}') endPattern = @"\" + endPattern;
      pattern += endPattern;
      MatchCollection matches = Regex.Matches(input, pattern);
      Console.WriteLine(pattern);
      int commentNumber = 0;
      foreach (Match match in matches)
         Console.WriteLine("{0}: {1}", ++commentNumber, match.Groups[1].Value);

   }
}
// The example shows possible output from the example:
//       Enter begin comment symbol: [
//       Enter end comment symbol: ]
//       \[(.*?)\]
//       1: comment comment comment
//       2: comment

Universal Windows Platform
Disponible depuis 4.5
.NET Framework
Disponible depuis 1.1
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: