Regex Construtores

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

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

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 usando dados serializados.
Regex(String, RegexOptions)	Inicializa uma nova instância da classe Regex para a expressão regular especificada, com opções que modificam 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 por quanto tempo um método de correspondência de padrões deve tentar uma correspondência antes de atingir o tempo limite.

Regex()

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

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 classe Regex.

Aplica-se a

Regex(String)

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

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 a ser correspondido.

Exceções

ArgumentException

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

ArgumentNullException

pattern é null.

Exemplos

O exemplo a seguir ilustra como usar esse construtor para criar uma instância de 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 construtor Regex(String, RegexOptions).

Comentários

Aviso

Ao usar System.Text.RegularExpressions para processar entradas não confiáveis, passe um valor de tempo limite para impedir que usuários mal-intencionados causem um ataque de negação de serviço . Um valor de tempo limite 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.

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

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

Um objeto Regex é 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 qualquer caractere alfabético definido em pattern. Para uma correspondência que não diferencia maiúsculas de minúsculas, use o construtor Regex.Regex(String, RegexOptions).

Notas aos Chamadores

Esse construtor cria um objeto Regex 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 objeto Regex usará o valor InfiniteMatchTimeout, o que impede que a operação reduza o tempo limite. O construtor recomendado para criar um objeto Regex é Regex(String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

elementos de linguagem de expressão regular

Aplica-se a

Regex(SerializationInfo, StreamingContext)

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

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 usando 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 RegexOptions informações.

context: StreamingContext

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

Atributos: ObsoleteAttribute

Exceções

ArgumentException

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

ArgumentNullException

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

ArgumentOutOfRangeException

info contém um sinalizador de RegexOptions inválido.

Aplica-se a

Regex(String, RegexOptions)

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

Inicializa uma nova instância da classe Regex para a expressão regular especificada, com opções que modificam 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 a ser correspondido.

options: RegexOptions

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

Exceções

ArgumentException

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

ArgumentNullException

pattern é null.

ArgumentOutOfRangeException

options contém um sinalizador inválido.

Exemplos

O exemplo a seguir ilustra como usar esse construtor para criar uma instância de 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 de correspondências inclui a palavra "O" que inicia o texto porque o parâmetro options tem comparações que não diferenciam maiúsculas de minúsculas.

Comentários

Aviso

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

Notas aos Chamadores

Confira também

elementos de linguagem de expressão regular

Aplica-se a

Regex(String, RegexOptions, TimeSpan)

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

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 por quanto tempo um método de correspondência de padrões 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 a ser correspondido.

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 ter tempo limite.

Exceções

ArgumentException

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

ArgumentNullException

pattern é null.

ArgumentOutOfRangeException

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

-ou-

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

Exemplos

O exemplo a seguir chama o construtor Regex(String, RegexOptions, TimeSpan) para criar uma instância de um objeto Regex com um valor de tempo limite de um segundo. O padrão de expressão regular (a+)+$, que corresponde a uma ou mais sequências de um ou mais caracteres "a" no final de uma linha, está sujeito a um 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 parâmetro matchTimeout 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 exceção RegexMatchTimeoutException. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o objeto Regex é criado. Os métodos de correspondência de padrões de instância que observam o intervalo de tempo limite matchTimeout incluem o seguinte:

A configuração de um intervalo de tempo limite impede que expressões regulares que dependem do 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 backtracking. 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 do computador esperada. 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 parâmetro matchTimeout como um valor apropriado, como dois segundos. Se você desabilitar o tempo limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular 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 com eficiência correspondências, não correspondências e correspondências próximas.
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

retrocesso em expressões regulares
elementos de linguagem de expressão regular

Aplica-se a

Compartilhar via

Regex Construtores

Definição

Sobrecargas

Regex()

Comentários

Aplica-se a

Regex(String)

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Regex(SerializationInfo, StreamingContext)

Parâmetros

Exceções

Aplica-se a

Regex(String, RegexOptions)

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Regex(String, RegexOptions, TimeSpan)

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Recursos adicionais