Regex.Escape(String) Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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.

public:
 static System::String ^ Escape(System::String ^ str);

public static string Escape (string str);

static member Escape : string -> string

Public Shared Function Escape (str As String) As String

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.

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

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim keyEntered As ConsoleKeyInfo
      Dim beginComment, endComment As Char
      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()
      
      Dim input As String = "Text [comment comment comment] more text [comment]"
      Dim pattern As String = Regex.Escape(beginComment.ToString()) + "(.*?)"
      Dim endPattern As String = Regex.Escape(endComment.ToString())
      If endComment = "]"c OrElse endComment = "}"c Then endPattern = "\" + endPattern
      pattern += endPattern
      
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      Console.WriteLine(pattern)
      Dim commentNumber As Integer = 0
      For Each match As Match In matches
         commentNumber += 1
         Console.WriteLine("{0}: {1}", commentNumber, match.Groups(1).Value)
      Next         
   End Sub
End Module
' 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.

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

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

Dim matches As MatchCollection = Regex.Matches(input, pattern)
Dim commentNumber As Integer = 0
Console.WriteLine("{0} produces the following matches:", pattern)
For Each match As Match In matches
   commentNumber += 1
   Console.WriteLine("{0}: {1}", commentNumber, match.Value)       
Next      
' This example displays the following output:
'       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.

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

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

Dim matches As MatchCollection = Regex.Matches(input, pattern)
Dim commentNumber As Integer = 0
Console.WriteLine("{0} produces the following matches:", pattern)
For Each match As Match In matches
   commentNumber += 1
   Console.WriteLine("   {0}: {1}", commentNumber, match.Value)  
Next
' 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

Condividi tramite