Regex Constructores

Definición

Espacio de nombres:

System.Text.RegularExpressions

Ensamblado:

System.Text.RegularExpressions.dll

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

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 se puede llamar por clases derivadas de la Regex clase .

Regex(String)

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

ArgumentException

Se produjo un error de análisis de expresión regular.

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

• Elementos de lenguaje de expresiones regulares

Regex(SerializationInfo, StreamingContext)

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

[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

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

ObsoleteAttribute

Excepciones

ArgumentException

Se produjo un error de análisis de expresión regular.

ArgumentNullException

El modelo que contiene info es null.

ArgumentOutOfRangeException

info contiene una marca RegexOptions no válida.

Regex(String, RegexOptions)

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

ArgumentException

Se produjo un error de análisis de expresión regular.

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

• Elementos de lenguaje de expresiones regulares

Regex(String, RegexOptions, TimeSpan)

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

ArgumentException

Se produjo un error de análisis de expresión regular.

ArgumentNullException

pattern es null.

ArgumentOutOfRangeException

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:

• IsMatch

• Match

• Matches

• Replace

• Split

• Match.NextMatch

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

• Retroceso en expresiones regulares
• Elementos de lenguaje de expresiones regulares