Regex Constructores

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

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 mediante datos serializados.
Regex(String, RegexOptions)	Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con opciones que modifican el patrón.
Regex(String, RegexOptions, TimeSpan)	Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con opciones que modifican el patrón y un valor que especifica cuánto tiempo debe intentar un método coincidente de patrones antes de que se agote el tiempo de espera.

Regex()

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Inicializa una nueva instancia de la clase Regex.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Comentarios

Tenga en cuenta que este constructor está protegido; Solo las clases derivadas de la clase Regex pueden llamar a ella.

Se aplica a

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 que se va a coincidir.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

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 con 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 constructor Regex(String, RegexOptions).

Comentarios

Advertencia

Al usar para procesar la entrada que no es de confianza, pase un valor de tiempo de espera para evitar que los usuarios malintencionados causen un ataque de denegación de servicio . Un valor de tiempo de espera especifica cuánto tiempo debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera de un método de coincidencia.

El parámetro pattern 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, consulte los temas expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida temas.

Llamar al constructor Regex(String) equivale a llamar al constructor Regex(String, RegexOptions) con un valor de None para el argumento options.

Un objeto Regex 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 con distinción entre mayúsculas y minúsculas de los caracteres alfabéticos definidos en pattern. Para una coincidencia que no distingue mayúsculas de minúsculas, use el constructor Regex.Regex(String, RegexOptions).

Notas a los autores de las llamadas

Este constructor crea un objeto Regex 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 objeto Regex usa el valor InfiniteMatchTimeout, lo que impide que se agote el tiempo de espera de la operación. El constructor recomendado para crear un objeto Regex es Regex(String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

elementos del lenguaje de expresiones regulares

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 mediante 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 patrón serializado y RegexOptions información.

context: StreamingContext

Destino de esta serialización. (Este parámetro no se usa; especifique null).

Atributos: ObsoleteAttribute

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

El patrón que info contiene es null.

ArgumentOutOfRangeException

info contiene una marca de 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 patrón.

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 que se va a coincidir.

options: RegexOptions

Combinación bit a bit de los valores de enumeración que modifican la expresión regular.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

pattern es null.

ArgumentOutOfRangeException

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 con 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 parámetro options ha definido comparaciones que no distinguen mayúsculas de minúsculas.

Comentarios

Advertencia

Un objeto Regex 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

Consulte también

elementos del lenguaje de expresiones regulares

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 opciones que modifican el patrón y un valor que especifica cuánto tiempo debe intentar un método coincidente de patrones 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 que se va a coincidir.

options: RegexOptions

Combinación bit a bit de los valores de enumeración que modifican la expresión regular.

matchTimeout: TimeSpan

Intervalo de tiempo de espera o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

pattern es null.

ArgumentOutOfRangeException

options no es un valor de RegexOptions válido.

-o-

matchTimeout es negativo, cero o mayor que aproximadamente 24 días.

Ejemplos

En el ejemplo siguiente se llama al constructor Regex(String, RegexOptions, TimeSpan) para crear instancias de un objeto Regex con un valor de tiempo de espera de un segundo. El patrón de expresión regular (a+)+$, que coincide con una o varias secuencias de uno o varios caracteres "a" al final de una línea, está sujeto a un retroceso excesivo. Si se produce un RegexMatchTimeoutException, 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 parámetro matchTimeout especifica cuánto tiempo debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera de un método de coincidencia. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método de coincidencia de patrones produce una excepción de RegexMatchTimeoutException. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se crea el objeto Regex. Los métodos de coincidencia de patrones de instancia que observan el intervalo de tiempo de espera de matchTimeout incluyen lo siguiente:

Si se establece un intervalo de tiempo de espera, se impide que las expresiones regulares que se basan en un retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de 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 los sistemas que tienen un uso elevado de CPU y memoria.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout 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

Compartir a través de

Regex Constructores

Definición

Sobrecargas

Regex()

Comentarios

Se aplica a

Regex(String)

Parámetros

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Regex(SerializationInfo, StreamingContext)

Parámetros

Excepciones

Se aplica a

Regex(String, RegexOptions)

Parámetros

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Regex(String, RegexOptions, TimeSpan)

Parámetros

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Recursos adicionales