Regex Construtores

Definição

Inicializa uma nova instância da classe Regex.

Sobrecargas

Regex()

Inicializa uma nova instância da classe Regex.

Regex(String)

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

Regex(SerializationInfo, StreamingContext)
Obsoleto.

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

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.

Regex()

Inicializa uma nova instância da classe Regex.

protected:
 Regex();
protected Regex ();
Protected Sub New ()

Comentários

Observe que esse construtor está protegido; ele só pode ser chamado por classes derivadas da Regex classe .

Aplica-se a

Regex(String)

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

public:
 Regex(System::String ^ pattern);
public Regex (string pattern);
new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String)

Parâmetros

pattern
String

O padrão de expressão regular para correspondência.

Exceções

Ocorreu um erro de análise da expressão regular.

pattern é null.

Exemplos

O exemplo a seguir ilustra como usar esse construtor para instanciar uma expressão regular que corresponda a qualquer palavra que comece com as letras "a" ou "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Observe que o padrão de expressão regular não pode corresponder à palavra "O" no início do texto, pois as comparações diferenciam maiúsculas de minúsculas por padrão. Para obter um exemplo de comparação que não diferencia maiúsculas de minúsculas, consulte o Regex(String, RegexOptions) construtor .

Comentários

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte os tópicos Expressões Regulares do .NET e Linguagem de Expressão Regular – Referência Rápida .

Chamar o Regex(String) construtor é equivalente a chamar o Regex(String, RegexOptions) construtor com um valor de None para o options argumento .

Um Regex objeto é imutável, o que significa que ele só pode ser usado para o padrão de correspondência definido quando você o cria. No entanto, ele pode ser usado várias vezes sem ser recompilado.

Esse construtor cria uma instância de um objeto de expressão regular que tenta uma correspondência que diferencia maiúsculas de minúsculas de quaisquer caracteres alfabéticos definidos em pattern. Para uma correspondência que não diferencia maiúsculas de minúsculas, use o Regex.Regex(String, RegexOptions) construtor .

Notas aos Chamadores

Esse construtor cria um Regex objeto que usa o valor de tempo limite padrão do domínio do aplicativo no qual ele é criado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o Regex objeto usará o valor InfiniteMatchTimeout, o que impede que a operação atinja o tempo limite. O construtor recomendado para criar um Regex objeto é Regex(String, RegexOptions, TimeSpan), que permite definir o intervalo de tempo limite.

Confira também

Aplica-se a

Regex(SerializationInfo, StreamingContext)

Cuidado

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

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

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parâmetros

info
SerializationInfo

O objeto que contém um padrão serializado e informações da RegexOptions.

context
StreamingContext

O destino dessa serialização. (Este parâmetro não é usado; especifique null.)

Atributos

Exceções

Ocorreu um erro de análise da expressão regular.

O padrão que info contém é null.

info contém um sinalizador RegexOptions inválido.

Aplica-se a

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.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions)

Parâmetros

pattern
String

O padrão de expressão regular para correspondência.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que modificam a expressão regular.

Exceções

Ocorreu um erro de análise da expressão regular.

pattern é null.

options contém um sinalizador inválido.

Exemplos

O exemplo a seguir ilustra como usar esse construtor para instanciar uma expressão regular que corresponda a qualquer palavra que comece com as letras "a" ou "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Observe que a coleção match inclui a palavra "The" que inicia o texto porque o options parâmetro definiu comparações que não diferenciam maiúsculas de minúsculas.

Comentários

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte os tópicos Expressões Regulares do .NET e Linguagem de Expressão Regular – Referência Rápida .

Um Regex objeto é imutável, o que significa que ele só pode ser usado para os parâmetros de correspondência definidos ao criá-lo. No entanto, ele pode ser usado várias vezes sem ser recompilado.

Notas aos Chamadores

Esse construtor cria um Regex objeto que usa o valor de tempo limite padrão do domínio do aplicativo no qual ele é criado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o Regex objeto usará o valor InfiniteMatchTimeout, o que impede que a operação atinja o tempo limite. O construtor recomendado para criar um Regex objeto é Regex(String, RegexOptions, TimeSpan), que permite definir o intervalo de tempo limite.

Confira também

Aplica-se a

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.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Parâmetros

pattern
String

O padrão de expressão regular para correspondência.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que modificam a expressão regular.

matchTimeout
TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.

Exceções

Ocorreu um erro de análise da expressão regular.

pattern é null.

options não é um valor RegexOptions válido.

- ou -

matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

Exemplos

O exemplo a seguir chama o Regex(String, RegexOptions, TimeSpan) construtor para instanciar um Regex objeto com um valor de tempo limite de um segundo. O padrão de expressão regular (a+)+$, que faz a correspondência de uma ou várias sequências de um ou mais caracteres de “a” no final de uma linha, está sujeito ao retrocesso excessivo. Se um RegexMatchTimeoutException for gerado, o exemplo aumentará o valor de tempo limite até o valor máximo de três segundos. Caso contrário, ele abandonará a tentativa de corresponder ao padrão.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

Comentários

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte os tópicos Expressões Regulares do .NET e Linguagem de Expressão Regular – Referência Rápida .

Um Regex objeto é imutável, o que significa que ele só pode ser usado para o padrão de correspondência que você define ao criá-lo. No entanto, ele pode ser usado várias vezes sem ser recompilado.

O matchTimeout parâmetro especifica por quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de atingir o tempo limite. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método de correspondência de padrões gerará uma RegexMatchTimeoutException exceção. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o Regex objeto é criado. Os métodos de correspondência de padrões de instância que observam o matchTimeout intervalo de tempo limite incluem o seguinte:

Definir um intervalo de tempo limite impede que expressões regulares que dependem de retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas. Para obter mais informações, consulte Práticas recomendadas para expressões regulares e retrocesso. Para definir um intervalo de tempo limite razoável, considere os seguintes fatores:

  • O comprimento e a complexidade do padrão de expressão regular. Expressões regulares mais longas e complexas exigem mais tempo do que as mais curtas e simples.

  • A carga esperada do computador. O processamento leva mais tempo em sistemas que têm alta utilização de CPU e memória.

Notas aos Chamadores

Recomendamos que você defina o matchTimeout parâmetro como um valor apropriado, como dois segundos. Se você desabilitar tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressões regulares oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite apenas nas seguintes condições:

  • Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.

  • Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule correspondências, não correspondências e correspondências próximas com eficiência.

  • Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.

Confira também

Aplica-se a