Regex.Escape(String) Método

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Faz escape de um conjunto mínimo de caracteres (\, *, +, ?, |, {, [, (,), ^, $, ., #, e espaço em branco) substituindo-os por seus códigos de escape. Isso instrui o mecanismo de expressões regulares para interpretar esses caracteres literalmente em vez de metacaracteres.

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

Parâmetros

str: String

A cadeia de caracteres de entrada que contém o texto a ser convertido.

Retornos

String

Uma cadeia de caracteres com metacaracteres convertidos em sua forma de escape.

Exceções

ArgumentNullException

str é null.

Exemplos

O exemplo a seguir extrai comentários do texto. Ele pressupõe que os comentários sejam delimitados por um símbolo de comentário inicial e um símbolo de comentário final selecionado pelo usuário. Como os símbolos de comentário devem ser interpretados literalmente, eles são passados para o Escape método para garantir que não possam ser interpretados incorretamente como metacaractadores. Além disso, o exemplo verifica explicitamente se o símbolo de comentário final inserido pelo usuário é um colchete de fechamento (]) ou chave (}). Se for, um caractere de barra invertida (\) será pré-acrescentado ao colchete ou à chave para que ele seja interpretado literalmente. Observe que o exemplo também usa a Match.Groups coleção apenas para exibir o comentário, em vez do comentário junto com seus símbolos de comentário de abertura e fechamento.

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

Comentários

Escape converte uma cadeia de caracteres para que o mecanismo de expressão regular interprete os metacaracters que ele possa conter como literais de caracteres. Por exemplo, considere uma expressão regular projetada para extrair comentários delimitados por colchetes de abertura e fechamento diretos ([ e ]) do texto. No exemplo a seguir, a expressão regular "[(.*?)]" é interpretada como uma classe de caractere. Em vez de corresponder aos comentários inseridos no texto de entrada, a expressão regular corresponde a cada parêntese de abertura ou fechamento, ponto de partida, asterisco ou ponto de interrogação.

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

No entanto, se o colchete de abertura for escapado passando-o para o Escape método, a expressão regular terá êxito em comentários correspondentes inseridos na cadeia de caracteres de entrada. O exemplo a seguir ilustra isto.

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

Em uma expressão regular definida usando texto estático, os caracteres que devem ser interpretados literalmente em vez de metacaractadores podem ser escapados precedendo-os com um símbolo de barra invertida (\) e chamando o Escape método. Em uma expressão regular definida dinamicamente usando caracteres que não são conhecidos em tempo de design, chamar o Escape método é particularmente importante para garantir que o mecanismo de expressão regular interprete caracteres individuais como literais e não como metacaractadores.

Observação

Se um padrão de expressão regular incluir o sinal de número (#) ou caracteres literais de espaço em branco, eles deverão ser escapados se o texto de entrada for analisado com a opção RegexOptions.IgnorePatternWhitespace habilitada.

Embora o Escape método escape do colchete de abertura reto ([) e dos caracteres de chave de abertura ({), ele não escapa de seus caracteres de fechamento correspondentes (] e }). Na maioria dos casos, não é necessário escapar deles. Se um colchete ou chave de fechamento não for precedido por seu caractere de abertura correspondente, o mecanismo de expressão regular o interpretará literalmente. Se um colchete de abertura ou chave for interpretado como um metacaracter, o mecanismo de expressão regular interpretará o primeiro caractere de fechamento correspondente como um metacaracter. Se esse não for o comportamento desejado, o colchete de fechamento ou a chave devem ser escapados, acrescentando explicitamente o caractere de barra invertida (\). Para obter uma ilustração, consulte a seção Exemplo.

Aplica-se a