Regex Constructores
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Inicializa una nueva instancia de la clase Regex.
Sobrecargas
Regex() |
Inicializa una nueva instancia de la clase Regex. |
Regex(String) |
Inicializa una nueva instancia de la clase Regex para la expresión regular especificada. |
Regex(SerializationInfo, StreamingContext) |
Obsoletos.
Inicializa una nueva instancia de la clase Regex con datos serializados. |
Regex(String, RegexOptions) |
Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con opciones que modifican el modelo. |
Regex(String, RegexOptions, TimeSpan) |
Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con las opciones que modifican el modelo y un valor que especifica cuánto tiempo debe intentar un método de coincidencia de modelos una coincidencia antes de que se agote el tiempo de espera. |
Regex()
Regex(String)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Inicializa una nueva instancia de la clase Regex para la expresión 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
Patrón de expresión regular del que van a buscarse coincidencias.
Excepciones
Se produjo un error de análisis de expresión regular.
pattern
es null
.
Ejemplos
En el ejemplo siguiente se muestra cómo usar este constructor para crear instancias de una expresión regular que coincida con cualquier palabra que comience por las letras "a" o "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
Tenga en cuenta que el patrón de expresión regular no puede coincidir con la palabra "The" al principio del texto, ya que las comparaciones distinguen mayúsculas de minúsculas de forma predeterminada. Para obtener un ejemplo de comparación sin distinción entre mayúsculas y minúsculas, vea el Regex(String, RegexOptions) constructor .
Comentarios
El pattern
parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea los temas Expresiones regulares de .NET y Lenguaje de expresiones regulares: Referencia rápida .
Llamar al Regex(String) constructor equivale a llamar al Regex(String, RegexOptions) constructor con un valor de None para el options
argumento .
Un Regex objeto es inmutable, lo que significa que solo se puede usar para el patrón de coincidencia que defina al crearlo. Sin embargo, se puede usar cualquier número de veces sin volver a compilarse.
Este constructor crea una instancia de un objeto de expresión regular que intenta una coincidencia que distingue mayúsculas de minúsculas de los caracteres alfabéticos definidos en pattern
. Para una coincidencia que no distingue mayúsculas de minúsculas, use el Regex.Regex(String, RegexOptions) constructor .
Notas a los autores de las llamadas
Este constructor crea un Regex objeto que usa el valor de tiempo de espera predeterminado del dominio de aplicación en el que se crea. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, el Regex objeto usa el valor InfiniteMatchTimeout, lo que impide que se agote el tiempo de espera de la operación. El constructor recomendado para crear un Regex objeto es Regex(String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera.
Consulte también
Se aplica a
Regex(SerializationInfo, StreamingContext)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Precaución
This API supports obsolete formatter-based serialization. It should not be called or extended by application code.
Inicializa una nueva instancia de la clase Regex con datos 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
Objeto que contiene un modelo serializado e información de RegexOptions.
- context
- StreamingContext
Destino de esta serialización. (Este parámetro no se usa; especifique null
).
- Atributos
Excepciones
Se produjo un error de análisis de expresión regular.
El modelo que contiene info
es null
.
info
contiene una marca RegexOptions no válida.
Se aplica a
Regex(String, RegexOptions)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con opciones que modifican el modelo.
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
Patrón de expresión regular del que van a buscarse coincidencias.
- options
- RegexOptions
Combinación bit a bit de los valores de enumeración que modifican la expresión regular.
Excepciones
Se produjo un error de análisis de expresión regular.
pattern
es null
.
options
contiene una marca no válida.
Ejemplos
En el ejemplo siguiente se muestra cómo usar este constructor para crear instancias de una expresión regular que coincida con cualquier palabra que comience por las letras "a" o "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
Tenga en cuenta que la colección match incluye la palabra "The" que comienza el texto porque el options
parámetro ha definido comparaciones que no distinguen mayúsculas de minúsculas.
Comentarios
El pattern
parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea los temas Expresiones regulares de .NET y Lenguaje de expresiones regulares: Referencia rápida .
Un Regex objeto es inmutable, lo que significa que solo se puede usar para los parámetros de coincidencia que defina al crearlo. Sin embargo, se puede usar cualquier número de veces sin volver a compilarse.
Notas a los autores de las llamadas
Este constructor crea un Regex objeto que usa el valor de tiempo de espera predeterminado del dominio de aplicación en el que se crea. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, el Regex objeto usa el valor InfiniteMatchTimeout, lo que impide que se agote el tiempo de espera de la operación. El constructor recomendado para crear un Regex objeto es Regex(String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera.
Consulte también
Se aplica a
Regex(String, RegexOptions, TimeSpan)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con las opciones que modifican el modelo y un valor que especifica cuánto tiempo debe intentar un método de coincidencia de modelos una coincidencia antes de que se agote el tiempo de espera.
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
Patrón de expresión regular del que van a buscarse coincidencias.
- options
- RegexOptions
Combinación bit a bit de los valores de enumeración que modifican la expresión regular.
- matchTimeout
- TimeSpan
Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.
Excepciones
Se produjo un error de análisis de expresión regular.
pattern
es null
.
options
no es un valor RegexOptions válido.
o bien
matchTimeout
es negativo, cero o mayor que 24 días aproximadamente.
Ejemplos
En el ejemplo siguiente se llama al Regex(String, RegexOptions, TimeSpan) constructor para crear una instancia de un Regex objeto con un valor de tiempo de espera de un segundo. El patrón de expresión regular (a+)+$
, que coincide con una o más secuencias de uno o varios caracteres "a" al final de una línea, está sujeto a un retroceso excesivo. Si se produce una RegexMatchTimeoutException excepción , el ejemplo aumenta el valor de tiempo de espera hasta el valor máximo de tres segundos. De lo contrario, abandona el intento de coincidir con el patrón.
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.
Comentarios
El pattern
parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea los temas Expresiones regulares de .NET y Lenguaje de expresiones regulares: Referencia rápida .
Un Regex objeto es inmutable, lo que significa que solo se puede usar para el patrón de coincidencia que se define al crearlo. Sin embargo, se puede usar cualquier número de veces sin volver a compilarse.
El matchTimeout
parámetro especifica cuánto tiempo debe intentar encontrar una coincidencia un método de coincidencia antes de que se agote el tiempo de espera. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método de coincidencia de patrones produce una RegexMatchTimeoutException excepción. matchTimeout
invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se crea el Regex objeto. Los métodos de coincidencia de patrones de instancia que observan el matchTimeout
intervalo de tiempo de espera incluyen lo siguiente:
Establecer un intervalo de tiempo de espera impide que las expresiones regulares que se basan en un retroceso excesivo parezcan dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea Procedimientos recomendados para expresiones regulares y retroceso. Para establecer un intervalo de tiempo de espera razonable, tenga en cuenta los siguientes factores:
Longitud y complejidad del patrón de expresión regular. Las expresiones regulares más largas y complejas requieren más tiempo que las más cortas y más sencillas.
Carga esperada de la máquina. El procesamiento tarda más tiempo en sistemas que tienen un uso elevado de CPU y memoria.
Notas a los autores de las llamadas
Se recomienda establecer el matchTimeout
parámetro en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:
Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.
Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.
Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.
Consulte también
Se aplica a
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea:Enviar y ver comentarios de