Regex.Escape(String) Metodo

Definizione

Spazio dei nomi:

System.Text.RegularExpressions

Assembly:

netstandard.dll, System.Text.RegularExpressions.dll

Origine:

Regex.cs

Esegue l'escape di un set minimo di caratteri (\, *, +, ?, |, {, [, (,), ^, $, ., #e spazio vuoto) sostituendoli con i relativi codici di escape. In questo modo il motore delle espressioni regolari interpreta questi caratteri letteralmente anziché come metacaratteri.

C#

public static string Escape(string str);

Parametri

str

String

Stringa di input che contiene il testo da convertire.

Restituisce

String

Stringa di caratteri con metacaratteri convertiti nel relativo formato di escape.

Eccezioni

ArgumentNullException

str è null.

Esempio

L'esempio seguente estrae i commenti dal testo. Presuppone che i commenti siano delimitati da un simbolo di commento iniziale e un simbolo di commento finale selezionato dall'utente. Poiché i simboli di commento devono essere interpretati letteralmente, vengono passati al Escape metodo per assicurarsi che non possano essere interpretati erroneamente come metacharacter. Inoltre, l'esempio verifica in modo esplicito se il simbolo di commento finale immesso dall'utente è una parentesi quadre di chiusura (]) o parentesi graffe (}). Se è, un carattere barra rovesciata (\) viene preceduto dalla parentesi quadre o dalla parentesi graffe in modo che venga interpretato letteralmente. Si noti che l'esempio usa anche la raccolta per visualizzare solo Match.Groups il commento, anziché il commento insieme ai simboli di apertura e chiusura dei commenti.

C#

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

Commenti

Escape converte una stringa in modo che il motore di espressioni regolari interpreti qualsiasi metacharacter che può contenere come valori letterali di carattere. Si consideri, ad esempio, un'espressione regolare progettata per estrarre i commenti delimitati da parentesi quadre di apertura e chiusura dritte ([ e ]) dal testo. Nell'esempio seguente l'espressione regolare "[(.*?)]" viene interpretata come classe di caratteri. Anziché trovare commenti corrispondenti incorporati nel testo di input, l'espressione regolare corrisponde a ogni parentesi di apertura o chiusura, periodo, asterisco o punto interrogativo.

C#

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: .

Tuttavia, se la parentesi di apertura viene eliminata passandola al Escape metodo, l'espressione regolare ha esito positivo nei commenti corrispondenti incorporati nella stringa di input. Questa condizione è illustrata nell'esempio seguente.

C#

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?]

In un'espressione regolare definita tramite testo statico, i caratteri che devono essere interpretati letteralmente anziché come metacharacter possono essere escape preceduti da un simbolo di barra rovesciata (\) e chiamando il Escape metodo. In un'espressione regolare definita in modo dinamico usando caratteri non noti in fase di progettazione, chiamare il metodo è particolarmente importante per garantire che il Escape motore di espressioni regolari interpreti i singoli caratteri come valori letterali anziché come metacharacter.

Nota

Se un modello di espressione regolare include il segno di numero (#) o i caratteri dello spazio vuoto letterale, è necessario eseguire l'escape se il testo di input viene analizzato con l'opzione RegexOptions.IgnorePatternWhitespace abilitata.

Mentre il Escape metodo rimuove aprendo tra parentesi quadre ([) e caratteri di parentesi graffe ({), rimuove i corrispondenti caratteri di chiusura (] e}). Nella maggior parte dei casi, lo scappato non è necessario. Se una parentesi quadre di chiusura o una parentesi graffe non è preceduta dal carattere di apertura corrispondente, il motore di espressioni regolari lo interpreta letteralmente. Se una parentesi quadre di apertura o una parentesi graffe viene interpretata come metacharacter, il motore di espressioni regolari interpreta il primo carattere di chiusura corrispondente come metacharacter. Se questo non è il comportamento desiderato, la parentesi quadre di chiusura o la parentesi graffe deve essere eliminata in modo esplicito pre-in sospeso dal carattere della barra rovesciata (\). Per un'illustrazione, vedere la sezione Esempio.

Si applica a

Vedi anche

• Unescape(String)
• Linguaggio di espressioni regolari - Riferimento rapido
• Caratteri di escape nelle espressioni regolari