Regex Construtores

Definição

Espaço de Nomes:

System.Text.RegularExpressions

Assemblagens:

netstandard.dll, System.Text.RegularExpressions.dll

Inicializa uma nova instância da Regex classe.

Sobrecargas

Name	Descrição
Regex()	Inicializa uma nova instância da Regex classe.
Regex(String)	Inicializa uma nova instância da Regex classe para a expressão regular especificada.
Regex(SerializationInfo, StreamingContext)	Obsoleto. Inicializa uma nova instância da Regex classe usando dados serializados.
Regex(String, RegexOptions)	Inicializa uma nova instância da Regex classe para a expressão regular especificada, com opções que modificam o padrão.
Regex(String, RegexOptions, TimeSpan)	Inicializa uma nova instância da Regex classe para a expressão regular especificada, com opções que modificam o padrão e um valor que especifica quanto tempo um método de correspondência de padrões deve tentar fazer correspondência antes de expirar.

Regex()

Origem:

Regex.cs

Inicializa uma nova instância da Regex classe.

protected:
 Regex();

protected Regex();

Protected Sub New ()

Observações

Note que este construtor está protegido; só pode ser chamado por classes derivadas da Regex classe.

Regex(String)

Origem:

Regex.cs

Inicializa uma nova instância da Regex classe 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 corresponder.

Exceções

ArgumentException

Ocorreu um erro de análise sintática de expressões regulares.

ArgumentNullException

pattern é null.

Exemplos

O exemplo seguinte ilustra como usar este construtor para instanciar uma expressão regular que corresponde 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

Note que o padrão de expressão regular não pode corresponder à palavra "The" no início do texto, porque as comparações são sensíveis a maiúsculas minúsculas por defeito. Para um exemplo de comparação insensível a maiúsculas e contas, veja o Regex(String, RegexOptions) construtor.

Observações

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte os tópicos .NET Expressões Regulares e Linguagem de Expressões Regulares - 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 objeto é imutável, o que significa que só pode ser usado para o padrão de correspondência que Regex define ao criá-lo. No entanto, pode ser usado qualquer número de vezes sem ser recompilado.

Este construtor instancia um objeto de expressão regular que tenta uma correspondência distinta a maiúsculas e minúsculas de quaisquer caracteres alfabéticos definidos em pattern. Para uma correspondência insensível a maiúsculas e minúsculas, use o Regex.Regex(String, RegexOptions) construtor.

Notas para Chamadores

Este construtor cria um Regex objeto que utiliza o valor de time-out padrão do domínio de aplicação onde é criado. Se não tiver sido definido um valor de time-out para o domínio de aplicação, o Regex objeto usa o valor InfiniteMatchTimeout, que impede que a operação expire. O construtor recomendado para criar um Regex objeto é Regex(String, RegexOptions, TimeSpan), que permite definir o intervalo de time-out.

Ver também

• Elementos da Linguagem de Expressões Regulares

Regex(SerializationInfo, StreamingContext)

Origem:

Regex.cs

Atenção

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

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

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

[<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 e RegexOptions informação serializados.

context

StreamingContext

O destino desta serialização. (Este parâmetro não é utilizado; especificar null.)

Atributos

ObsoleteAttribute

Exceções

ArgumentException

Ocorreu um erro de análise sintática de expressões regulares.

ArgumentNullException

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

ArgumentOutOfRangeException

info contém uma bandeira inválida RegexOptions .

PlatformNotSupportedException

A serialização de Regex objetos não é suportada.

Regex(String, RegexOptions)

Origem:

Regex.cs

Inicializa uma nova instância da Regex classe 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 para corresponder.

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 sintática de expressões regulares.

ArgumentNullException

pattern é null.

ArgumentOutOfRangeException

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

Exemplos

O exemplo seguinte ilustra como usar este construtor para instanciar uma expressão regular que corresponde 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

Note que a coleção de correspondências inclui a palavra "The" que inicia o texto porque o options parâmetro tem comparações definidas insensíveis a maiúsculas e minúsculas.

Observações

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

Um Regex objeto é imutável, o que significa que só pode ser usado para os parâmetros de correspondência que define ao criá-lo. No entanto, pode ser usado qualquer número de vezes sem ser recompilado.

Notas para Chamadores

Este construtor cria um Regex objeto que utiliza o valor de time-out padrão do domínio de aplicação onde é criado. Se não tiver sido definido um valor de time-out para o domínio de aplicação, o Regex objeto usa o valor InfiniteMatchTimeout, que impede que a operação expire. O construtor recomendado para criar um Regex objeto é Regex(String, RegexOptions, TimeSpan), que permite definir o intervalo de time-out.

Ver também

• Elementos da Linguagem de Expressões Regulares

Regex(String, RegexOptions, TimeSpan)

Origem:

Regex.cs

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

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 corresponder.

options

RegexOptions

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

matchTimeout

TimeSpan

Um intervalo de time-out, ou InfiniteMatchTimeout para indicar que o método não deve expirar.

Exceções

ArgumentException

Ocorreu um erro de análise sintática de expressões regulares.

ArgumentNullException

pattern é null.

ArgumentOutOfRangeException

options não é um valor válido RegexOptions , ou matchTimeout é negativo, zero ou superior a aproximadamente 24 dias.

Exemplos

O exemplo seguinte chama o Regex(String, RegexOptions, TimeSpan) construtor a instanciar um Regex objeto com um valor de time-out de um segundo. O padrão (a+)+$de expressão regular, que corresponde a uma ou mais sequências de um ou mais caracteres "a" no final de uma linha, está sujeito a retrocesso excessivo. Se for lançado a RegexMatchTimeoutException , o exemplo aumenta o valor de time-out até ao valor máximo de três segundos. Caso contrário, abandona 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.

Observações

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

Um Regex objeto é imutável, o que significa que só pode ser usado para o padrão de correspondência que defines ao criá-lo. No entanto, pode ser usado qualquer número de vezes sem ser recompilado.

O matchTimeout parâmetro especifica quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de expirar. Se não for encontrada correspondência nesse intervalo de tempo, o método de correspondência de padrões lança uma RegexMatchTimeoutException exceção. matchTimeout sobrepõe qualquer valor de time-out padrão definido para o domínio de aplicação onde o Regex objeto é criado. Os métodos de correspondência de padrões de instâncias que observam o matchTimeout intervalo de time-out incluem os seguintes:

• IsMatch

• Match

• Matches

• Replace

• Split

• Match.NextMatch

Definir um intervalo de tempo impede que expressões regulares que dependem de retrocessos excessivos pareçam deixar de responder quando processam entradas que contenham correspondências próximas. Para mais informações, consulte Melhores Práticas para Expressões Regulares e Retrocesso. Para definir um intervalo de tempo razoável, considere os seguintes fatores:

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

• A carga esperada da máquina. O processamento demora mais tempo em sistemas com elevada utilização de CPU e memória.

Notas para Chamadores

Recomendamos que defina o matchTimeout parâmetro para um valor apropriado, como dois segundos. Se desativar os tempos de espera especificando InfiniteMatchTimeout, o motor de expressão regular oferece um desempenho ligeiramente melhor. No entanto, deve desativar os tempos de espera apenas nas seguintes condições:

• Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e de confiança ou consiste em texto estático. Isto exclui texto que tenha sido introduzido dinamicamente pelos utilizadores.

• Quando o padrão de expressão regular foi cuidadosamente testado para garantir que lida eficientemente com correspondências, não correspondências e próximas correspondências.

• 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.

Ver também

• Retrocesso em expressões regulares
• Elementos da Linguagem de Expressões Regulares