Classe Regex (System.Text.RegularExpressions)

O System.String classe inclui vários métodos de comparação e de pesquisa que você pode usar para realizar de padrões coincidentes com o texto. Por exemplo, o String.Contains, String.EndsWith, e String.StartsWith métodos de determinam se uma ocorrência de string contém uma subseqüência especificada; e o String.IndexOf, String.IndexOfAny, String.LastIndexOf, e String.LastIndexOfAny métodos retornam a posição inicial de uma subseqüência especificada em uma seqüência de caracteres. Use os métodos da System.String classe quando você estiver procurando por uma seqüência específica. Use o Regex classe quando você estiver procurando por um padrão específico em uma seqüência de caracteres. For more information and examples, see Expressões Regulares do .NET Framework.

Depois de definir um padrão de expressão regular, você pode fornecê-lo para o mecanismo de expressão regular de duas maneiras.

• Instanciando um Regex objeto que representa a expressão regular. Para fazer isso, você passa o padrão de expressão regular para um Regex construtor. Um Regex objeto é imutável; Quando você instancia um Regex de objeto com uma expressão regular, que a expressão regular do objeto não pode ser alterado.

• Fornecendo tanto a expressão regular como o texto a pesquisar para um static (Shared em Visual Basic) Regex método. Isso permite que você use uma expressão regular, sem criar explicitamente um Regex objeto.

Todos os Regex métodos de identificação padrão incluem estáticos e instância sobrecargas.

O mecanismo de expressão regular deve compilar um padrão específico para que o padrão que possa ser usado. Porque Regex são imutáveis, este é um único procedimento que ocorre quando um Regex o construtor de classe ou um método estático é chamado. Para eliminar a necessidade de compilar repetidamente uma única expressão regular, o mecanismo de expressão regular, armazena em cache as expressões regulares compiladas, usadas em chamadas de método estático. Como resultado, os métodos de correspondência de padrão de expressão regular oferecem um desempenho comparável estática e métodos de instância.

Importante
No.NET Framework versões 1.0 e 1.1, todos compilados expressões regulares, se elas foram usados em chamadas de método estático ou de instância, foram armazenados em cache. Começando com o.NET Framework 2.0, somente as expressões regulares utilizadas nas chamadas de método estático são armazenados em cache.

No entanto, o sistema de cache implementado pelo mecanismo de expressão regular pode afetar negativamente o desempenho nos seguintes casos:

• Quando você usa o método estático chamadas com um grande número de expressões regulares. Por padrão, o mecanismo de expressão regular caches 15 usadas recentemente expressões regulares estáticas. Se o seu aplicativo usa as expressões regulares mais de 15 estáticas, algumas expressões regulares devem ser recompilados. Para evitar essa recompilação, você pode aumentar a Regex.CacheSize propriedade para um valor apropriado.

• Quando seu aplicativo instancia novas Regex objetos com expressões regulares que foram compilados anteriormente. Por exemplo, o código a seguir define uma expressão regular para localizar palavras duplicadas em linhas individuais de um fluxo de texto. Embora o exemplo usa uma única expressão regular, instancia um novo Regex o objeto para processar cada linha de texto. Isso resulta na recompilação da expressão regular com cada iteração do loop.

  Visual Basic

  
  Dim sr As New StreamReader(filename)
  Dim input As String
  Dim pattern As String = "\b(\w+)\s\1\b"
  Do While sr.Peek() >= 0
     input = sr.ReadLine()
     Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
     Dim matches As MatchCollection = rgx.Matches(input)
     If matches.Count > 0 Then
        Console.WriteLine("{0} ({1} matches):", input, matches.Count)
        For Each match As Match In matches
           Console.WriteLine("   " + match.Value)
        Next   
     End If
  Loop
  sr.Close()   
  
  
  

  C#

  
  StreamReader sr = new StreamReader(filename);
  string input;
  string pattern = @"\b(\w+)\s\1\b";
  while (sr.Peek() >= 0)
  {
     input = sr.ReadLine();
     Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
     MatchCollection matches = rgx.Matches(input);
     if (matches.Count > 0)
     {
        Console.WriteLine("{0} ({1} matches):", input, matches.Count);
        foreach (Match match in matches)
           Console.WriteLine("   " + match.Value);
     }
  }
  sr.Close();   
  
  
  

  Para evitar a recompilação, o aplicativo deve instanciar um único Regex reescrita de objeto que está acessível a todos os códigos que exija, conforme mostrado no seguinte exemplo.

  Visual Basic

  
  Dim sr As New StreamReader(filename)
  Dim input As String
  Dim pattern As String = "\b(\w+)\s\1\b"
  Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
  Do While sr.Peek() >= 0
     input = sr.ReadLine()
     Dim matches As MatchCollection = rgx.Matches(input)
     If matches.Count > 0 Then
        Console.WriteLine("{0} ({1} matches):", input, matches.Count)
        For Each match As Match In matches
           Console.WriteLine("   " + match.Value)
        Next   
     End If
  Loop
  sr.Close()   
  
  
  

  C#

  
  StreamReader sr = new StreamReader(filename);
  string input;
  string pattern = @"\b(\w+)\s\1\b";
  Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
  
  while (sr.Peek() >= 0)
  {
     input = sr.ReadLine();
     MatchCollection matches = rgx.Matches(input);
     if (matches.Count > 0)
     {
        Console.WriteLine("{0} ({1} matches):", input, matches.Count);
        foreach (Match match in matches)
           Console.WriteLine("   " + match.Value);
     }
  }
  sr.Close();   
  
  
  

Se você decidir criar uma instância de um Regex de objeto e chamar seus métodos ou chamar métodos estáticos, a Regex classe oferece as seguintes funcionalidades de correspondência de padrões:

• Validação de uma correspondência. Você chamar o IsMatch método para determinar se uma correspondência está presente.

• Recuperação de uma única correspondência. Você chamar o Match método para recuperar um Match objeto que representa a primeira correspondência em uma seqüência ou em parte de uma seqüência de caracteres. Correspondências subseqüentes podem ser recuperadas chamando o Match.NextMatch método.

• Recuperação de todas as correspondências. Você chamar o Matches método para recuperar um System.Text.RegularExpressions.MatchCollection objeto que representa todas as correspondências encontradas em uma seqüência ou em parte de uma seqüência de caracteres.

• Substituição de texto correspondente. Você chamar o Replace método para substituir o texto correspondente. O texto de substituição também pode ser definido por uma expressão regular. Além disso, alguns do Replace métodos incluem um MatchEvaluator parâmetro que permite que você programaticamente definir o texto de substituição.

• Criação de uma matriz de cadeia de caracteres é formada de partes de uma seqüência de caracteres de entrada. Você chamar o Split método para dividir uma cadeia de entrada em posições que são definidos pela expressão regular.

Além de para seus métodos de correspondência de padrões, o Regex classe inclui vários métodos de propósito especial:

• O Escape método expõe todos os caracteres que podem ser interpretados como operadores de expressões regulares em uma expressão regular ou seqüência de caracteres de entrada.

• O Unescape método remove esses caracteres de escape.

• O CompileToAssembly método cria um assembly que contém expressões regulares predefinidas. A.NET Framework contém exemplos desses assemblies de finalidade especial na System.Web.RegularExpressions namespace.