Regex Classe

Definição

Representa uma expressão regular imutável.

public ref class Regex
public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
type Regex = class
    interface ISerializable
[<System.Serializable>]
type Regex = class
    interface ISerializable
Public Class Regex
Public Class Regex
Implements ISerializable
Herança
Regex
Derivado
Atributos
Implementações

Exemplos

O exemplo a seguir usa uma expressão regular para verificar se há ocorrências repetidas de palavras em uma cadeia de caracteres. A expressão \b(?<word>\w+)\s+(\k<word>)\b regular pode ser interpretada conforme mostrado na tabela a seguir.

Padrão Descrição
\b Inicie a correspondência em um limite de palavras.
(?<word>\w+) Corresponda um ou mais caracteres de palavra a um limite de palavras. Nomeie esse grupo wordcapturado.
\s+ Corresponde a um ou mais caracteres de espaço em branco.
(\k<word>) Corresponda ao grupo capturado nomeado word.
\b Corresponder a um limite de palavra.
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumps over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}",
                          matches.Count,
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",
                              groups["word"].Value,
                              groups[0].Index,
                              groups[1].Index);
        }
    }
}

// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 49 and 53
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 49 and 53

O exemplo a seguir ilustra o uso de uma expressão regular para verificar se uma cadeia de caracteres representa um valor de moeda ou tem o formato correto para representar um valor de moeda. Nesse caso, a expressão regular é criada dinamicamente a partir das NumberFormatInfo.CurrencyDecimalSeparatorNumberFormatInfo.NegativeSignCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolpropriedades, e NumberFormatInfo.PositiveSign propriedades para a cultura atual do usuário. Se a cultura atual do sistema for en-US, a expressão regular resultante será ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Essa expressão regular pode ser interpretada conforme mostrado na tabela a seguir.

Padrão Descrição
^ Comece no início da cadeia de caracteres.
\s* Corresponder a zero ou mais caracteres de espaço em branco.
[\+-]? Corresponder a zero ou uma ocorrência do sinal positivo ou do sinal negativo.
\s? Corresponder a zero ou a um caractere de espaço em branco.
\$? Corresponder a zero ou uma ocorrência do sinal de dólar.
\s? Corresponder a zero ou a um caractere de espaço em branco.
\d* Corresponde a zero ou mais dígitos decimais.
\.? Corresponder a zero ou um símbolo de ponto decimal.
\d{2}? Corresponda a dois dígitos decimais zero ou uma vez.
(\d*\.?\d{2}?){1} Corresponda ao padrão de dígitos integrais e fracionários separados por um símbolo de ponto decimal pelo menos uma vez.
$ Corresponda ao final da cadeia de caracteres.

Nesse caso, a expressão regular pressupõe que uma cadeia de caracteres de moeda válida não contenha símbolos separadores de grupo e que não tenha dígitos fracionários ou o número de dígitos fracionários definidos pela propriedade da CurrencyDecimalDigits cultura atual.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern; 
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";
      
      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = NumberFormatInfo.CurrentInfo

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$"
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

Como a expressão regular neste exemplo é criada dinamicamente, não sabemos no momento do design se o símbolo de moeda, o sinal decimal ou os sinais positivos e negativos da cultura atual podem ser interpretados incorretamente pelo mecanismo de expressão regular como operadores de linguagem de expressão regular. Para evitar qualquer interpretação incorreta, o exemplo passa cada cadeia de caracteres gerada dinamicamente para o Escape método.

Comentários

A Regex classe representa o mecanismo de expressão regular do .NET Framework. Ele pode ser usado para analisar rapidamente grandes quantidades de texto para encontrar padrões de caracteres específicos; para extrair, editar, substituir ou excluir subcadeias de texto; e adicionar as cadeias de caracteres extraídas a uma coleção para gerar um relatório.

Observação

Se o seu interesse principal é validar uma cadeia de caracteres determinando se ela está em conformidade com um padrão específico, você pode usar a System.Configuration.RegexStringValidator classe.

Para usar expressões regulares, defina o padrão que deseja identificar em um fluxo de texto usando a sintaxe documentada na Linguagem de Expressão Regular – Referência Rápida. Em seguida, opcionalmente, você pode criar uma instância de um Regex objeto. Por fim, você chama um método que executa alguma operação, como substituir texto que corresponde ao padrão de expressão regular ou identificar uma correspondência de padrão.

Observação

Para alguns padrões comuns de expressão regular, consulte Exemplos de Expressão Regular. Há também várias bibliotecas online de padrões de expressão regulares, como a de Regular-Expressions.info.

Para obter mais informações sobre como usar a Regex classe, consulte as seguintes seções neste tópico:

Para saber mais sobre a linguagem de expressão regular, confira Linguagem de expressão regular - referência rápida ou faça download e imprima um dos seguintes folhetos:

Referência rápida no formato Word (.docx)
Referência rápida no formato PDF (.pdf)

Regex x métodos da cadeia de caracteres

A System.String classe inclui vários métodos de pesquisa e comparação que você pode usar para executar a correspondência de padrões com texto. Por exemplo, o , e os String.Containsmétodos determinam se uma instância de cadeia de caracteres contém uma subcadeia de caracteres especificada; e os String.IndexOfAnyString.IndexOfmétodos , String.LastIndexOfe String.LastIndexOfAny retornam a posição inicial de uma subcadeia de caracteres especificada em uma cadeia de caracteres.String.StartsWith String.EndsWith Use os métodos da System.String classe quando estiver procurando uma cadeia de caracteres específica. Use a Regex classe quando estiver procurando um padrão específico em uma cadeia de caracteres. Para obter mais informações e exemplos, consulte Expressões Regulares do .NET.

Voltar para Comentários

Métodos estáticos x instância

Depois de definir um padrão de expressão regular, você poderá fornecê-lo ao mecanismo de expressão regular de duas maneiras:

  • Ao criar uma instância de 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ê cria uma instância de um Regex objeto com uma expressão regular, a expressão regular desse objeto não pode ser alterada.

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

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

O mecanismo de expressão regular deve compilar um padrão específico antes que o padrão possa ser usado. Como Regex os objetos são imutáveis, esse é um procedimento único que ocorre quando um Regex 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ões de expressão regular oferecem desempenho comparável para métodos estáticos e de instância.

Importante

No .NET Framework versões 1.0 e 1.1, todas as expressões regulares compiladas, sejam elas usadas em chamadas de método estático ou instância, foram armazenadas em cache. A partir do .NET Framework 2.0, somente expressões regulares usadas em chamadas de método estático são armazenadas em cache.

No entanto, o cache pode afetar negativamente o desempenho nos dois casos a seguir:

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

  • Quando você cria uma instância de novos Regex objetos com expressões regulares que foram compiladas anteriormente. Por exemplo, o código a seguir define uma expressão regular para localizar palavras duplicadas em um fluxo de texto. Embora o exemplo use uma única expressão regular, ele cria uma instância de um novo Regex objeto para processar cada linha de texto. Isso resulta na recompilação da expressão regular com cada iteração do loop.

    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();
    
    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()
    

    Para evitar a recompilação, você deve criar uma instância de um único Regex objeto acessível a todo o código que o exija, conforme mostrado no exemplo reescrito a seguir.

    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();
    
    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()
    

Voltar para Comentários

Executando operações de expressão regular

Se você decidir instanciar um Regex objeto e chamar seus métodos ou chamar métodos estáticos, a Regex classe oferece a seguinte funcionalidade de correspondência de padrões:

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

  • Recuperação de uma única correspondência. Você chama o Match método para recuperar um Match objeto que representa a primeira correspondência em uma cadeia de caracteres ou em parte de uma cadeia de caracteres. As correspondências subsequentes podem ser recuperadas chamando o Match.NextMatch método.

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

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

  • Criação de uma matriz de cadeia de caracteres formada a partir de partes de uma cadeia de caracteres de entrada. Você chama o Split método para dividir uma cadeia de caracteres de entrada em posições definidas pela expressão regular.

Além de seus métodos de correspondência de padrões, a Regex classe inclui vários métodos de finalidade especial:

  • O Escape método escapa de todos os caracteres que podem ser interpretados como operadores de expressão regular em uma expressão regular ou cadeia 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. O .NET Framework contém exemplos desses assemblies de finalidade especial no System.Web.RegularExpressions namespace.

Voltar para Comentários

Definindo um valor de tempo limite

O .NET dá suporte a uma linguagem de expressão regular completa que fornece poder e flexibilidade substanciais na correspondência de padrões. No entanto, a potência e a flexibilidade vêm a um custo: o risco de um desempenho ruim. Expressões regulares que têm um desempenho ruim são surpreendentemente fáceis de criar. Em alguns casos, as operações de expressão regulares que dependem do retrocesso excessivo podem parecer parar de responder quando processam texto que quase corresponde ao padrão de expressão regular. Para obter mais informações sobre o mecanismo de Expressão Regular do .NET, consulte Detalhes do comportamento de expressão regular. Para obter mais informações sobre retrocesso excessivo, consulte Backtracking.

Começando com o .NET Framework 4.5, você pode definir um intervalo de tempo limite para correspondências de expressão regulares para limitar o retrocesso excessivo. Dependendo do padrão de expressão regular e do texto de entrada, o tempo de execução pode exceder o intervalo de tempo limite especificado, mas não passará mais tempo retrocedendo do que o intervalo de tempo limite especificado. Se o mecanismo de expressão regular atingir o tempo limite, ele gerará uma RegexMatchTimeoutException exceção. Na maioria dos casos, isso impede que o mecanismo de expressão regular desmeda o poder de processamento tentando corresponder ao texto que quase corresponde ao padrão de expressão regular. Ele também pode indicar, no entanto, que o intervalo de tempo limite foi definido muito baixo ou que a carga do computador atual causou uma degradação geral no desempenho.

A forma como você lida com a exceção depende da causa da exceção. Se a exceção ocorrer porque o intervalo de tempo limite é definido muito baixo ou devido à carga excessiva do computador, você pode aumentar o intervalo de tempo limite e repetir a operação correspondente. Se a exceção ocorrer porque a expressão regular depende de retrocesso excessivo, você pode supor que uma correspondência não existe e, opcionalmente, você pode registrar informações que ajudarão você a modificar o padrão de expressão regular.

Você pode definir um intervalo de tempo limite chamando o Regex(String, RegexOptions, TimeSpan) construtor quando instanciar um objeto de expressão regular. Para métodos estáticos, você pode definir um intervalo de tempo limite chamando uma sobrecarga de um método correspondente que tem um matchTimeout parâmetro. Se você não definir um valor de tempo limite explicitamente, o valor de tempo limite padrão será determinado da seguinte maneira:

  • Usando o valor de tempo limite de todo o aplicativo, se houver um. Esse pode ser qualquer valor de tempo limite que se aplica ao domínio do aplicativo no qual o Regex objeto é instanciado ou a chamada de método estático é feita. Você pode definir o valor de tempo limite de todo o aplicativo chamando o AppDomain.SetData método para atribuir a representação de cadeia de caracteres de um TimeSpan valor à propriedade "REGEX_DEFAULT_MATCH_TIMEOUT".

  • Usando o valor InfiniteMatchTimeout, se nenhum valor de tempo limite de todo o aplicativo tiver sido definido.

Importante

Recomendamos que você defina um valor de tempo limite em todas as operações regulares de correspondência de padrões de expressão. Para obter mais informações, consulte As práticas recomendadas para expressões regulares.

Voltar para Comentários

Construtores

Regex()

Inicializa uma nova instância da classe Regex.

Regex(SerializationInfo, StreamingContext)

Inicializa uma nova instância da classe Regex utilizando dados serializados.

Regex(String)

Inicializa uma nova instância da classe Regex para a expressão regular especificada.

Regex(String, RegexOptions)

Inicializa uma nova instância da classe Regex para a expressão regular especificada, com opções que modifiquem o padrão.

Regex(String, RegexOptions, TimeSpan)

Inicializa uma nova instância da classe Regex para a expressão regular especificada, com opções que modificam o padrão e um valor que especifica quanto tempo um padrão que corresponde ao método deve tentar uma correspondência antes de atingir o tempo limite.

Campos

capnames

Usado por um objeto Regex gerado pelo método CompileToAssembly.

caps

Usado por um objeto Regex gerado pelo método CompileToAssembly.

capsize

Usado por um objeto Regex gerado pelo método CompileToAssembly.

capslist

Usado por um objeto Regex gerado pelo método CompileToAssembly.

factory

Usado por um objeto Regex gerado pelo método CompileToAssembly.

InfiniteMatchTimeout

Especifica que uma operação de correspondência de padrões não deve atingir o tempo limite.

internalMatchTimeout

A quantidade de tempo máxima que pode decorrer em uma operação de correspondência de padrões antes que a operação atinja o tempo limite.

pattern

Usado por um objeto Regex gerado pelo método CompileToAssembly.

roptions

Usado por um objeto Regex gerado pelo método CompileToAssembly.

Propriedades

CacheSize

Obtém ou define o número máximo de entradas no cache estático atual de expressões regulares compiladas.

CapNames

Obtém ou define um dicionário que mapeia grupos de captura nomeados para seus valores de índice.

Caps

Obtém ou define um dicionário que mapeia grupos de captura numerados para seus valores de índice.

MatchTimeout

Obtém o intervalo de tempo limite da instância atual.

Options

Obtém as opções que foram passadas para o construtor Regex.

RightToLeft

Obtém um valor que indica se a expressão regular pesquisa da direita para a esquerda.

Métodos

CompileToAssembly(RegexCompilationInfo[], AssemblyName)
Obsoleto.

Compila um ou mais objetos Regex especificados para um assembly nomeado.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])
Obsoleto.

Compila um ou mais objetos Regex especificados para um assembly nomeado com os atributos especificados.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)
Obsoleto.

Compila um ou mais objetos Regex especificados e um arquivo de recurso especificado para um assembly nomeado com os atributos especificados.

Count(ReadOnlySpan<Char>)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(ReadOnlySpan<Char>, String)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(ReadOnlySpan<Char>, String, RegexOptions)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(String)

Pesquisa uma cadeia de caracteres de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(String, String)

Pesquisa uma cadeia de caracteres de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(String, String, RegexOptions)

Pesquisa uma cadeia de caracteres de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

Count(String, String, RegexOptions, TimeSpan)

Pesquisa uma cadeia de caracteres de entrada para todas as ocorrências de uma expressão regular e retorna o número de correspondências.

EnumerateMatches(ReadOnlySpan<Char>)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna um Regex.ValueMatchEnumerator para iterar sobre as correspondências.

EnumerateMatches(ReadOnlySpan<Char>, String)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna um Regex.ValueMatchEnumerator para iterar sobre as correspondências.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna um Regex.ValueMatchEnumerator para iterar ao longo das correspondências.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Pesquisa um intervalo de entrada para todas as ocorrências de uma expressão regular e retorna um Regex.ValueMatchEnumerator para iterar ao longo das correspondências.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
Escape(String)

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.

Finalize()

Este membro substitui Finalize(), e pode haver uma documentação mais completa disponível nesse tópico.

Permite que um Object tente liberar recursos e executar outras operações de limpeza antes que Object seja recuperado pela coleta de lixo.

GetGroupNames()

Retorna uma matriz de nomes de grupo de captura para a expressão regular.

GetGroupNumbers()

Retorna uma matriz de números de grupo de captura que correspondem aos nomes de grupos em uma matriz.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
GroupNameFromNumber(Int32)

Obtém o nome do grupo que corresponde ao número do grupo especificado.

GroupNumberFromName(String)

Retorna o número do grupo que corresponde ao nome do grupo especificado.

InitializeReferences()

Usado por um objeto Regex gerado pelo método CompileToAssembly.

IsMatch(ReadOnlySpan<Char>)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em um intervalo de entrada especificado.

IsMatch(ReadOnlySpan<Char>, String)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado, usando as opções de correspondência especificadas.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado, usando as opções de correspondência especificadas e o intervalo de tempo limite.

IsMatch(String)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em uma cadeia de caracteres de entrada especificada.

IsMatch(String, Int32)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência na cadeia de caracteres de entrada especificada, começando na posição inicial especificada na cadeia de caracteres.

IsMatch(String, String)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada.

IsMatch(String, String, RegexOptions)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas.

IsMatch(String, String, RegexOptions, TimeSpan)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada, usando as opções de correspondência e intervalo de tempo limite especificados.

Match(String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada no construtor Regex.

Match(String, Int32)

Procura a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.

Match(String, Int32, Int32)

Pesquisa a primeira ocorrência de uma expressão regular na cadeia de entrada, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres.

Match(String, String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada.

Match(String, String, RegexOptions)

Procura a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções especificadas de correspondência.

Match(String, String, RegexOptions, TimeSpan)

Pesquisa a cadeia de caracteres de entrada da primeira ocorrência da expressão regular especificada, usando as opções de correspondência e intervalo de tempo limite especificados.

Matches(String)

Pesquisa todas as ocorrências de uma expressão regular na cadeia de caracteres de entrada especificada.

Matches(String, Int32)

Pesquisa a cadeia de caracteres de entrada especificada para todas as ocorrências de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.

Matches(String, String)

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de entrada especificada.

Matches(String, String, RegexOptions)

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas.

Matches(String, String, RegexOptions, TimeSpan)

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas e o intervalo de tempo limite.

MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
Replace(String, MatchEvaluator)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator.

Replace(String, MatchEvaluator, Int32)

Em uma cadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres retornada por um delegado MatchEvaluator.

Replace(String, MatchEvaluator, Int32, Int32)

Em uma subcadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres retornada por um delegado MatchEvaluator.

Replace(String, String)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres de substituição especificada.

Replace(String, String, Int32)

Em uma cadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular com uma cadeia de caracteres substituta especificada.

Replace(String, String, Int32, Int32)

Em uma subcadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular com uma cadeia de caracteres substituta especificada.

Replace(String, String, MatchEvaluator)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator.

Replace(String, String, MatchEvaluator, RegexOptions)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator. As opções especificadas modificam a operação de correspondência.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

Em uma cadeia de caracteres de entrada especificada, substitui todas as subcadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.

Replace(String, String, String)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.

Replace(String, String, String, RegexOptions)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada. As opções especificadas modificam a operação de correspondência.

Replace(String, String, String, RegexOptions, TimeSpan)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.

Split(String)

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado no construtor Regex.

Split(String, Int32)

Divide uma cadeia de entrada no número de vezes máximo especificado em uma matriz de subcadeias de caracteres, nas posições definidas por uma expressão regular especificada no construtor Regex.

Split(String, Int32, Int32)

Divide uma cadeia de entrada no número de vezes máximo especificado em uma matriz de subcadeias de caracteres, nas posições definidas por uma expressão regular especificada no construtor Regex. A pesquisa do padrão de expressão regular é iniciada em uma posição de caractere especificada na cadeia de entrada.

Split(String, String)

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular.

Split(String, String, RegexOptions)

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado. As opções especificadas modificam a operação de correspondência.

Split(String, String, RegexOptions, TimeSpan)

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.

ToString()

Retorna o padrão de expressão regular que foi passado para o construtor Regex.

Unescape(String)

Converte qualquer caractere de escape na cadeia de caracteres de entrada.

UseOptionC()

Usado por um objeto Regex gerado pelo método CompileToAssembly.

UseOptionR()

Usado por um objeto Regex gerado pelo método CompileToAssembly.

ValidateMatchTimeout(TimeSpan)

Verifique se o intervalo de tempo limite está dentro de um intervalo aceitável.

Implantações explícitas de interface

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um objeto SerializationInfo com os dados necessários para desserializar o objeto Regex atual.

Aplica-se a

Acesso thread-safe

A Regex classe é imutável (somente leitura) e thread safe. Regex os objetos podem ser criados em qualquer thread e compartilhados entre threads. Para obter mais informações, consulte Thread Safety.

Confira também