Regex Construtores
Definição
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 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()
Regex(String)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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 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)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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 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)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
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)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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 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
Comentários
https://aka.ms/ContentUserFeedback.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulteEnviar e exibir comentários de