Regex Classe

Definição

Representa uma expressão regular imutável.Represents an immutable regular expression.

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

Exemplos

O exemplo a seguir usa uma expressão regular para verificar ocorrências repetidas de palavras em uma cadeia de caracteres.The following example uses a regular expression to check for repeated occurrences of words in a string. A expressão \b(?<word>\w+)\s+(\k<word>)\b regular pode ser interpretada conforme mostrado na tabela a seguir.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Inicie a correspondência em um limite de palavra.Start the match at a word boundary.
(?<word>\w+) Corresponder um ou mais caracteres de palavra até um limite de palavra.Match one or more word characters up to a word boundary. Nomeie esse grupo wordcapturado.Name this captured group word.
\s+ Corresponder um ou mais caracteres de espaço em branco.Match one or more white-space characters.
(\k<word>) Corresponda ao grupo capturado que é nomeado word.Match the captured group that is named word.
\b Corresponder a um limite de palavra.Match a word boundary.
#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 50 and 54
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 50 and 54

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 se tem o formato correto para representar um valor de moeda.The following example illustrates the use of a regular expression to check whether a string either represents a currency value or has the correct format to represent a currency value. Nesse caso, a expressão regular NumberFormatInfo.CurrencyDecimalSeparatoré criada dinamicamente a partir das propriedades CurrencyDecimalDigits NumberFormatInfo.CurrencySymbol,, NumberFormatInfo.NegativeSign, e NumberFormatInfo.PositiveSign para a cultura atual do usuário.In this case, the regular expression is built dynamically from the NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, and NumberFormatInfo.PositiveSign properties for the user's current culture. Se a cultura atual do sistema for en-US, a expressão regular resultante será ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Essa expressão regular pode ser interpretada conforme mostrado na tabela a seguir.This regular expression can be interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
^ Inicie no início da cadeia de caracteres.Start at the beginning of the string.
\s* Corresponder a zero ou mais caracteres de espaço em branco.Match zero or more white-space characters.
[\+-]? Corresponder zero ou uma ocorrência do sinal positivo ou do sinal negativo.Match zero or one occurrence of either the positive sign or the negative sign.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
\$? Corresponder a zero ou uma ocorrência do cifrão.Match zero or one occurrence of the dollar sign.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
\d* Corresponde a zero ou mais dígitos decimais.Match zero or more decimal digits.
\.? Corresponder a zero ou um símbolo de ponto decimal.Match zero or one decimal point symbol.
\d{2}? Corresponder dois dígitos decimais zero ou uma vez.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Corresponder o padrão de dígitos inteiros e fracionários separados por um símbolo de ponto decimal pelo menos uma vez.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Corresponder ao fim da cadeia de caracteres.Match the end of the string.

Nesse caso, a expressão regular pressupõe que uma cadeia de caracteres monetária válida não contenha símbolos de 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.In this case, the regular expression assumes that a valid currency string does not contain group separator symbols, and that it has either no fractional digits or the number of fractional digits defined by the current culture's CurrencyDecimalDigits property.

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 em tempo de design se o símbolo de moeda atual da cultura, o sinal decimal ou os sinais positivos e negativos podem ser interpretados erroneamente pelo mecanismo de expressão regular como regular operadores de linguagem de expressão.Because the regular expression in this example is built dynamically, we do not know at design time whether the current culture's currency symbol, decimal sign, or positive and negative signs might be misinterpreted by the regular expression engine as regular expression language operators. Para evitar qualquer interpretação inalguma, o exemplo passa cada cadeia de caracteres gerada Escape dinamicamente para o método.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Comentários

A Regex classe representa o mecanismo de expressão regular do .NET Framework.The Regex class represents the .NET Framework's regular expression engine. Ele pode ser usado para analisar rapidamente grandes quantidades de texto para localizar 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.It can be used to quickly parse large amounts of text to find specific character patterns; to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection to generate a report.

Observação

Se seu interesse principal é validar uma cadeia de caracteres determinando se ela está em conformidade com um padrão específico, você pode usar System.Configuration.RegexStringValidator a classe.If your primary interest is to validate a string by determining whether it conforms to a particular pattern, you can use the System.Configuration.RegexStringValidator class.

Para usar expressões regulares, você define o padrão que deseja identificar em um fluxo de texto usando a sintaxe documentada em linguagem de expressão regular – referência rápida.To use regular expressions, you define the pattern that you want to identify in a text stream by using the syntax documented in Regular Expression Language - Quick Reference. Em seguida, você pode opcionalmente criar Regex uma instância de um objeto.Next, you can optionally instantiate a Regex object. Por fim, você chama um método que executa alguma operação, como substituir o texto que corresponde ao padrão de expressão regular ou identificar uma correspondência de padrão.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

Observação

Para alguns padrões comuns de expressão regular, consulte exemplos de expressões regulares.For some common regular expression patterns, see Regular Expression Examples. Também há uma série de bibliotecas online de padrões de expressões regulares, como a Regular-Expressions.info.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Para obter mais informações sobre como Regex usar a classe, consulte as seguintes seções neste tópico:For more information about using the Regex class, see the following sections in this topic:

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:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Referência rápida no formato Word (.docx)Quick Reference in Word (.docx) format
Referência rápida no formato PDF (.pdf)Quick Reference in PDF (.pdf) format

Regex x métodos da cadeia de caracteresRegex vs. String Methods

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.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Por exemplo, os String.Containsmétodos String.EndsWith, e String.StartsWith determinam se uma instância de cadeia de caracteres contém uma subcadeia de String.IndexOfcaracteres String.IndexOfAny String.LastIndexOfespecificada; e String.LastIndexOfAny os métodos,, e retornam o início posição de uma subcadeia de caracteres especificada em uma cadeia de caracteres.For example, the String.Contains, String.EndsWith, and String.StartsWith methods determine whether a string instance contains a specified substring; and the String.IndexOf, String.IndexOfAny, String.LastIndexOf, and String.LastIndexOfAny methods return the starting position of a specified substring in a string. Use os métodos da System.String classe quando você estiver procurando uma cadeia de caracteres específica.Use the methods of the System.String class when you are searching for a specific string. Use a Regex classe quando você estiver procurando um padrão específico em uma cadeia de caracteres.Use the Regex class when you are searching for a specific pattern in a string. Para obter mais informações e exemplos, consulte .NET Framework expressões regulares.For more information and examples, see .NET Framework Regular Expressions.

Voltar a comentáriosBack to Remarks

Métodos estáticos x instânciaStatic vs. Instance Methods

Depois de definir um padrão de expressão regular, você pode fornecê-lo ao mecanismo de expressão regular de uma das duas maneiras:After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Instanciando um Regex objeto que representa a expressão regular.By instantiating a Regex object that represents the regular expression. Para fazer isso, você passa o padrão de expressão regular para Regex um construtor.To do this, you pass the regular expression pattern to a Regex constructor. Um Regex objeto é imutável; quando você cria uma instância Regex de um objeto com uma expressão regular, a expressão regular desse objeto não pode ser alterada.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Fornecendo a expressão regular e o texto a ser pesquisado em um static método (Shared no Visual Basic). RegexBy supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Isso permite que você use uma expressão regular sem criar explicitamente um Regex objeto.This enables you to use a regular expression without explicitly creating a Regex object.

Todos Regex os métodos de identificação de padrão incluem sobrecargas estática e de instância.All Regex pattern identification methods include both static and instance overloads.

O mecanismo de expressão regular deve compilar um padrão específico antes que o padrão possa ser usado.The regular expression engine must compile a particular pattern before the pattern can be used. 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.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. Para eliminar a necessidade de Compilar repetidamente uma única expressão regular, o mecanismo de expressões regulares armazena em cache as expressões regulares compiladas usadas em chamadas de método estáticos.To eliminate the need to repeatedly compile a single regular expression, the regular expression engine caches the compiled regular expressions used in static method calls. Como resultado, os métodos de correspondência de padrão de expressão regular oferecem desempenho comparável para métodos estáticos e de instância.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Importante

No .NET Framework versões 1,0 e 1,1, todas as expressões regulares compiladas, se elas foram usadas em chamadas de método estático ou de instância, foram armazenadas em cache.In the .NET Framework versions 1.0 and 1.1, all compiled regular expressions, whether they were used in instance or static method calls, were cached. A partir do .NET Framework 2,0, somente as expressões regulares usadas em chamadas de método estáticos são armazenadas em cache.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

No entanto, o cache pode afetar negativamente o desempenho nos dois casos a seguir:However, caching can adversely affect performance in the following two cases:

  • Quando você usa chamadas de método estático com um grande número de expressões regulares.When you use static method calls with a large number of regular expressions. Por padrão, o mecanismo de expressões regulares armazena em cache as 15 expressões regulares estáticas usadas mais recentemente.By default, the regular expression engine caches the 15 most recently used static regular expressions. Se seu aplicativo usar mais de 15 expressões regulares estáticas, algumas expressões regulares deverão ser recompiladas.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. Para evitar essa recompilação, você pode aumentar a Regex.CacheSize propriedade.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Quando você instancia novos Regex objetos com expressões regulares que foram previamente compiladas.When you instantiate new Regex objects with regular expressions that have previously been compiled. Por exemplo, o código a seguir define uma expressão regular para localizar palavras duplicadas em um fluxo de texto.For example, the following code defines a regular expression to locate duplicated words in a text stream. Embora o exemplo use uma única expressão regular, ele cria uma instância de Regex um novo objeto para processar cada linha de texto.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Isso resulta na recompilação da expressão regular com cada iteração do loop.This results in the recompilation of the regular expression with each iteration of the 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 Regex instância de um único objeto que seja acessível a todo o código que o exija, conforme mostrado no exemplo a seguir reescrito.To prevent recompilation, you should instantiate a single Regex object that is accessible to all code that requires it, as shown in the following rewritten example.

    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 a comentáriosBack to Remarks

Executando operações de expressão regularPerforming Regular Expression Operations

Se você decidir criar uma instância Regex de um objeto e chamar seus métodos ou chamar métodos estáticos, a Regex classe oferecerá a seguinte funcionalidade de correspondência de padrões:Whether you decide to instantiate a Regex object and call its methods or call static methods, the Regex class offers the following pattern-matching functionality:

  • Validação de uma correspondência.Validation of a match. Você chama o IsMatch método para determinar se uma correspondência está presente.You call the IsMatch method to determine whether a match is present.

  • Recuperação de uma única correspondência.Retrieval of a single match. 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.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. As correspondências subsequentes podem ser recuperadas chamando o Match.NextMatch método.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Recuperação de todas as correspondências.Retrieval of all matches. 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.You call the Matches method to retrieve a System.Text.RegularExpressions.MatchCollection object that represents all the matches found in a string or in part of a string.

  • Substituição de texto correspondente.Replacement of matched text. Você chama o Replace método para substituir o texto correspondente.You call the Replace method to replace matched text. O texto de substituição também pode ser definido por uma expressão regular.The replacement text can also be defined by a regular expression. Além disso, alguns dos Replace métodos incluem um MatchEvaluator parâmetro que permite que você defina programaticamente o texto de substituição.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Criação de uma matriz de cadeia de caracteres que é formada por partes de uma cadeia de caracteres de entrada.Creation of a string array that is formed from parts of an input string. Você chama o Split método para dividir uma cadeia de caracteres de entrada em posições que são definidas pela expressão regular.You call the Split method to split an input string at positions that are defined by the regular expression.

Além de seus métodos de correspondência de padrões, a Regex classe inclui vários métodos de finalidade especial:In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • O Escape método escapa todos os caracteres que podem ser interpretados como operadores de expressão regular em uma expressão regular ou uma cadeia de caracteres de entrada.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • O Unescape método remove esses caracteres de escape.The Unescape method removes these escape characters.

  • O CompileToAssembly método cria um assembly que contém expressões regulares predefinidas.The CompileToAssembly method creates an assembly that contains predefined regular expressions. O .NET Framework contém exemplos desses assemblies de finalidade especial no System.Web.RegularExpressions namespace.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Voltar a comentáriosBack to Remarks

Definindo um valor de tempo limiteDefining a Time-Out Value

O .NET Framework dá suporte a uma linguagem de expressão regular com recursos completos que fornece potência substancial e flexibilidade na correspondência de padrões.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. No entanto, o poder e a flexibilidade vêm a um custo: o risco de baixo desempenho.However, the power and flexibility come at a cost: the risk of poor performance. As expressões regulares que executam inadequadamente são surpreendentemente fáceis de criar.Regular expressions that perform poorly are surprisingly easy to create. Em alguns casos, as operações de expressão regular que dependem do retrocesso excessivo podem parecer parar de responder quando processam o texto que praticamente corresponde ao padrão de expressão regular.In some cases, regular expression operations that rely on excessive backtracking can appear to stop responding when they process text that nearly matches the regular expression pattern. Para obter mais informações sobre o .NET Framework mecanismo de expressão regular, consulte detalhes do comportamento de expressões regulares.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Para obter mais informações sobre o retrocesso excessivo, consulte retrocesso.For more information about excessive backtracking, see Backtracking.

Começando com o .NET Framework 4.5.NET Framework 4.5, você pode definir um intervalo de tempo limite para correspondências de expressão regular.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. Se o mecanismo de expressões regulares não puder identificar uma correspondência dentro desse intervalo de tempo, a operação RegexMatchTimeoutException de correspondência lançará uma exceção.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. Na maioria dos casos, isso impede que o mecanismo de expressão regular desperdiçasse poder de processamento tentando corresponder o texto que quase corresponde ao padrão de expressão regular.In most cases, this prevents the regular expression engine from wasting processing power by trying to match text that nearly matches the regular expression pattern. No entanto, também poderia indicar que o intervalo de tempo limite foi definido como muito baixo ou que a carga atual do computador causou uma degradação geral no desempenho.It also could indicate, however, that the timeout interval has been set too low, or that the current machine load has caused an overall degradation in performance.

A maneira como você manipula a exceção depende da causa da exceção.How you handle the exception depends on the cause of the exception. Se a exceção ocorrer porque o intervalo de tempo limite está definido como muito baixo ou devido à carga excessiva do computador, você pode aumentar o intervalo de tempo limite e repetir a operação correspondente.If the exception occurs because the time-out interval is set too low or because of excessive machine load, you can increase the time-out interval and retry the matching operation. Se a exceção ocorrer porque a expressão regular depende do retrocesso excessivo, você pode pressupor que uma correspondência não existe e, opcionalmente, você pode registrar informações que o ajudarão a modificar o padrão de expressão regular.If the exception occurs because the regular expression relies on excessive backtracking, you can assume that a match does not exist, and, optionally, you can log information that will help you modify the regular expression pattern.

Você pode definir um intervalo de tempo limite chamando o Regex(String, RegexOptions, TimeSpan) Construtor ao criar uma instância de um objeto de expressão regular.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. Para métodos estáticos, você pode definir um intervalo de tempo limite chamando uma sobrecarga de um método correspondente que tenha um matchTimeout parâmetro.For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. Se você não definir um valor de tempo limite explicitamente, o valor de tempo limite padrão será determinado da seguinte maneira:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • Usando o valor de tempo limite de todo o aplicativo, se existir um.By using the application-wide time-out value, if one exists. Isso pode ser qualquer valor de tempo limite que se aplica ao domínio do aplicativo no qual Regex o objeto é instanciado ou a chamada de método estático é feita.This can be any time-out value that applies to the application domain in which the Regex object is instantiated or the static method call is made. 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 TimeSpan caracteres de um valor à propriedade "REGEX_DEFAULT_MATCH_TIMEOUT".You can set the application-wide time-out value by calling the AppDomain.SetData method to assign the string representation of a TimeSpan value to the "REGEX_DEFAULT_MATCH_TIMEOUT" property.

  • Usando o valor InfiniteMatchTimeout, se nenhum valor de tempo limite de todo o aplicativo tiver sido definido.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Importante

Recomendamos que você defina um valor de tempo limite em todas as operações de correspondência de padrão de expressão regular.We recommend that you set a time-out value in all regular expression pattern-matching operations. Para obter mais informações, consulte práticas recomendadas para expressões regulares.For more information, see Best Practices for Regular Expressions.

Voltar a comentáriosBack to Remarks

Construtores

Regex()

Inicializa uma nova instância da classe Regex.Initializes a new instance of the Regex class.

Regex(SerializationInfo, StreamingContext)

Inicializa uma nova instância da classe Regex utilizando dados serializados.Initializes a new instance of the Regex class by using serialized data.

Regex(String)

Inicializa uma nova instância da classe Regex para a expressão regular especificada.Initializes a new instance of the Regex class for the specified regular expression.

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

Campos

capnames

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

caps

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capsize

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capslist

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

factory

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout

Especifica que uma operação de correspondência de padrões não deve atingir o tempo limite.Specifies that a pattern-matching operation should not time out.

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.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

roptions

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

Propriedades

CacheSize

Obtém ou define o número máximo de entradas no cache estático atual de expressões regulares compiladas.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames

Obtém ou define um dicionário que mapeia grupos de captura nomeados para seus valores de índice.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps

Obtém ou define um dicionário que mapeia grupos de captura numerados para seus valores de índice.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout

Obtém o intervalo de tempo limite da instância atual.Gets the time-out interval of the current instance.

Options

Obtém as opções que foram passadas para o construtor Regex.Gets the options that were passed into the Regex constructor.

RightToLeft

Obtém um valor que indica se a expressão regular pesquisa da direita para a esquerda.Gets a value that indicates whether the regular expression searches from right to left.

Métodos

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Compila um ou mais objetos Regex especificados para um assembly nomeado.Compiles one or more specified Regex objects to a named assembly.

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

Compila um ou mais objetos Regex especificados para um assembly nomeado com os atributos especificados.Compiles one or more specified Regex objects to a named assembly with the specified attributes.

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

Compila um ou mais objetos Regex especificados e um arquivo de recurso especificado para um assembly nomeado com os atributos especificados.Compiles one or more specified Regex objects and a specified resource file to a named assembly with the specified attributes.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(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.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. Isso instrui o mecanismo de expressões regulares para interpretar esses caracteres literalmente em vez de metacaracteres.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

Finalize()

Este membro substitui Finalize(), e pode haver uma documentação mais completa disponível nesse tópico.This member overrides Finalize(), and more complete documentation might be available in that topic.

Permite que um Object tente liberar recursos e executar outras operações de limpeza antes que Object seja recuperado pela coleta de lixo.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

GetGroupNames()

Retorna uma matriz de nomes de grupo de captura para a expressão regular.Returns an array of capturing group names for the regular expression.

GetGroupNumbers()

Retorna uma matriz de números de grupo de captura que correspondem aos nomes de grupos em uma matriz.Returns an array of capturing group numbers that correspond to group names in an array.

GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
GroupNameFromNumber(Int32)

Obtém o nome do grupo que corresponde ao número do grupo especificado.Gets the group name that corresponds to the specified group number.

GroupNumberFromName(String)

Retorna o número do grupo que corresponde ao nome do grupo especificado.Returns the group number that corresponds to the specified group name.

InitializeReferences()

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

IsMatch(String)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em uma cadeia de caracteres de entrada especificada.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

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.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada.Indicates whether the specified regular expression finds a match in the specified input string.

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.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

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.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

Match(String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada no construtor Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada.Searches the specified input string for the first occurrence of the specified regular expression.

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.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

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.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Matches(String)

Pesquisa todas as ocorrências de uma expressão regular na cadeia de caracteres de entrada especificada.Searches the specified input string for all occurrences of a regular expression.

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.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String)

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de entrada especificada.Searches the specified input string for all occurrences of a specified regular expression.

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.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

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.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

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.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. 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.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. 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.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

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.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

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.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. A pesquisa do padrão de expressão regular é iniciada em uma posição de caractere especificada na cadeia de entrada.The search for the regular expression pattern starts at a specified character position in the input string.

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.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

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.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

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.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. 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.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

ToString()

Retorna o padrão de expressão regular que foi passado para o construtor Regex.Returns the regular expression pattern that was passed into the Regex constructor.

Unescape(String)

Converte qualquer caractere de escape na cadeia de caracteres de entrada.Converts any escaped characters in the input string.

UseOptionC()

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

UseOptionR()

Usado por um objeto Regex gerado pelo método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

ValidateMatchTimeout(TimeSpan)

Verifique se o intervalo de tempo limite está dentro de um intervalo aceitável.Checks whether a time-out interval is within an acceptable range.

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.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

Aplica-se a

Acesso thread-safe

A Regex classe é imutável (somente leitura) e thread-safe.The Regex class is immutable (read-only) and thread safe. Regexos objetos podem ser criados em qualquer thread e compartilhados entre threads.Regex objects can be created on any thread and shared between threads. Para obter mais informações, consulte segurança do thread.For more information, see Thread Safety.

Veja também