Ler em inglês

Partilhar via


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

C#
protected Regex ();

Comentários

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

Aplica-se a

.NET 9 e outras versões
Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP 10.0

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.

C#
public Regex (string pattern);

Parâmetros

pattern
String

O padrão de expressão regular a ser correspondido.

Exceções

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

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

C#
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

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

.NET 9 e outras versões
Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP 10.0

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.

C#
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
C#
[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);

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

Exceções

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

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

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

Aplica-se a

.NET 9 e outras versões
Produto Versões (Obsoleto)
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7 (8, 9)
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

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.

C#
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);

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

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

pattern é null.

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

C#
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

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

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.

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

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

.NET 9 e outras versões
Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP 10.0

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.

C#
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

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

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

pattern é null.

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.

C#
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.

Comentários

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.

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.

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

Aplica-se a

.NET 9 e outras versões
Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP 10.0