Regex Clase

Definición

Representa una expresión regular inmutable.Represents an immutable regular expression.

public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
    interface ISerializable
Public Class Regex
Implements ISerializable
Herencia
Regex
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se usa una expresión regular para comprobar si hay apariciones repetidas de palabras en una cadena.The following example uses a regular expression to check for repeated occurrences of words in a string. La expresión regular \b(?<word>\w+)\s+(\k<word>)\b puede interpretarse como se muestra en la tabla siguiente.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

PatrónPattern DescripciónDescription
\b Iniciar la coincidencia en un límite de palabras.Start the match at a word boundary.
(?<word>\w+) Coincide con uno o varios caracteres de palabra hasta un límite de palabras.Match one or more word characters up to a word boundary. Asigne a este grupo capturado el nombre word.Name this captured group word.
\s+ Coincide con uno o más caracteres de espacio en blanco.Match one or more white-space characters.
(\k<word>) Coincide con el grupo capturado denominado word.Match the captured group that is named word.
\b Coincide con un límite de palabras.Match a word boundary.
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumps over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }
    }
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

En el ejemplo siguiente se muestra el uso de una expresión regular para comprobar si una cadena representa un valor de moneda o tiene el formato correcto para representar un valor de moneda.The following example illustrates the use of a regular expression to check whether a string either represents a currency value or has the correct format to represent a currency value. En este caso, la expresión regular se genera dinámicamente a partir de las propiedades NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSigny NumberFormatInfo.PositiveSign de la referencia cultural actual del usuario.In this case, the regular expression is built dynamically from the NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, and NumberFormatInfo.PositiveSign properties for the user's current culture. Si la referencia cultural actual del sistema es en-US, la expresión regular resultante es ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Esta expresión regular puede interpretarse como se muestra en la tabla siguiente.This regular expression can be interpreted as shown in the following table.

PatrónPattern DescripciónDescription
^ Comienza al principio de la cadena.Start at the beginning of the string.
\s* Busca coincidencias con cero o más caracteres de espacio en blanco.Match zero or more white-space characters.
[\+-]? Coincide con cero o una aparición del signo positivo o el signo negativo.Match zero or one occurrence of either the positive sign or the negative sign.
\s? Busca coincidencias con cero o un carácter de espacio en blanco.Match zero or one white-space character.
\$? Coincide con cero o una repetición del signo de dólar.Match zero or one occurrence of the dollar sign.
\s? Busca coincidencias con cero o un carácter de espacio en blanco.Match zero or one white-space character.
\d* Busca cero o más dígitos decimales.Match zero or more decimal digits.
\.? Coincide con cero o un símbolo de separador decimal.Match zero or one decimal point symbol.
\d{2}? Coincide cero o una vez con dos dígitos decimales.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Coincide con el patrón de dígitos enteros y fraccionarios separados por un símbolo de separador decimal al menos una vez.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Coincide con el final de la cadena.Match the end of the string.

En este caso, la expresión regular supone que una cadena de moneda válida no contiene símbolos de separador de grupo y que no tiene dígitos fraccionarios ni el número de dígitos fraccionarios definidos por la propiedad CurrencyDecimalDigits de la referencia cultural actual.In this case, the regular expression assumes that a valid currency string does not contain group separator symbols, and that it has either no fractional digits or the number of fractional digits defined by the current culture's CurrencyDecimalDigits property.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern; 
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";
      
      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = NumberFormatInfo.CurrentInfo

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$"
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

Dado que la expresión regular de este ejemplo se genera dinámicamente, no sabemos en tiempo de diseño si el motor de expresiones regulares puede interpretar erróneamente el símbolo de moneda, el signo decimal o los signos positivos y negativos del actual. operadores de lenguaje de expresiones.Because the regular expression in this example is built dynamically, we do not know at design time whether the current culture's currency symbol, decimal sign, or positive and negative signs might be misinterpreted by the regular expression engine as regular expression language operators. Para evitar una interpretación incorrecta, el ejemplo pasa cada cadena generada dinámicamente al método Escape.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Comentarios

La clase Regex representa el motor de expresiones regulares del .NET Framework.The Regex class represents the .NET Framework's regular expression engine. Se puede usar para analizar rápidamente grandes cantidades de texto para buscar patrones de caracteres específicos; para extraer, modificar, reemplazar o eliminar subcadenas de texto; y para agregar las cadenas extraídas a una colección para generar un informe.It can be used to quickly parse large amounts of text to find specific character patterns; to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection to generate a report.

Nota

Si su interés principal es validar una cadena determinando si se ajusta a un patrón determinado, puede usar la clase System.Configuration.RegexStringValidator.If your primary interest is to validate a string by determining whether it conforms to a particular pattern, you can use the System.Configuration.RegexStringValidator class.

Para usar expresiones regulares, defina el patrón que desea identificar en una secuencia de texto mediante la sintaxis documentada en referencia rápida del lenguaje de expresiones regulares.To use regular expressions, you define the pattern that you want to identify in a text stream by using the syntax documented in Regular Expression Language - Quick Reference. A continuación, puede crear una instancia de un objeto Regex.Next, you can optionally instantiate a Regex object. Por último, se llama a un método que realiza alguna operación, como reemplazar el texto que coincide con el patrón de expresión regular o identificar una coincidencia de patrón.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

Nota

Para ver algunos patrones de expresiones regulares comunes, vea ejemplos de expresiones regulares.For some common regular expression patterns, see Regular Expression Examples. También hay varias bibliotecas en línea de patrones de expresiones regulares, como la que se encuentra en regular-Expressions.info.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Para obtener más información sobre el uso de la clase Regex, vea las siguientes secciones de este tema:For more information about using the Regex class, see the following sections in this topic:

Para obtener más información acerca del lenguaje de expresiones regulares, consulte Lenguaje de expresiones regulares - Referencia rápida o descargue e imprima uno de estos folletos:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Referencia rápida en formato Word (.docx)Quick Reference in Word (.docx) format
Referencia rápida en formato PDF (.pdf)Quick Reference in PDF (.pdf) format

Regex frente a métodos de cadenaRegex vs. String Methods

La clase System.String incluye varios métodos de búsqueda y comparación que se pueden usar para realizar la coincidencia de patrones con el texto.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Por ejemplo, los métodos String.Contains, String.EndsWithy String.StartsWith determinan si una instancia de cadena contiene una subcadena especificada; y los métodos String.IndexOf, String.IndexOfAny, String.LastIndexOfy String.LastIndexOfAny devuelven la posición inicial de una subcadena especificada en una cadena.For example, the String.Contains, String.EndsWith, and String.StartsWith methods determine whether a string instance contains a specified substring; and the String.IndexOf, String.IndexOfAny, String.LastIndexOf, and String.LastIndexOfAny methods return the starting position of a specified substring in a string. Utilice los métodos de la clase System.String al buscar una cadena específica.Use the methods of the System.String class when you are searching for a specific string. Utilice la clase Regex cuando busque un patrón específico en una cadena.Use the Regex class when you are searching for a specific pattern in a string. Para obtener más información y ejemplos, vea .NET Framework expresiones regulares.For more information and examples, see .NET Framework Regular Expressions.

Volver a comentariosBack to Remarks

Métodos estáticos y de instanciaStatic vs. Instance Methods

Después de definir un patrón de expresión regular, puede proporcionarlo al motor de expresiones regulares de cualquiera de estas dos maneras:After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Creando una instancia de un objeto Regex que representa la expresión regular.By instantiating a Regex object that represents the regular expression. Para ello, pase el patrón de expresión regular a un constructor de Regex.To do this, you pass the regular expression pattern to a Regex constructor. Un objeto Regex es inmutable; al crear una instancia de un objeto de Regex con una expresión regular, no se puede cambiar la expresión regular de ese objeto.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Al proporcionar la expresión regular y el texto que se va a buscar en un static (Shared en Visual Basic) Regex método.By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Esto le permite usar una expresión regular sin crear explícitamente un objeto Regex.This enables you to use a regular expression without explicitly creating a Regex object.

Todos los métodos de identificación de patrón Regex incluyen sobrecargas estáticas y de instancia.All Regex pattern identification methods include both static and instance overloads.

El motor de expresiones regulares debe compilar un patrón determinado antes de que se pueda usar el patrón.The regular expression engine must compile a particular pattern before the pattern can be used. Dado que Regex objetos son inmutables, se trata de un procedimiento único que se produce cuando se llama a un constructor de clase Regex o a un método estático.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. Para eliminar la necesidad de compilar varias veces una sola expresión regular, el motor de expresiones regulares almacena en caché las expresiones regulares compiladas que se usan en las llamadas a métodos estáticos.To eliminate the need to repeatedly compile a single regular expression, the regular expression engine caches the compiled regular expressions used in static method calls. Como resultado, los métodos de coincidencia de patrones de expresión regular ofrecen un rendimiento comparable para los métodos estáticos y de instancia.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Importante

En las versiones 1,0 y 1,1 de .NET Framework, todas las expresiones regulares compiladas, tanto si se usaron en llamadas a métodos estáticos como de instancia, se almacenaron en caché.In the .NET Framework versions 1.0 and 1.1, all compiled regular expressions, whether they were used in instance or static method calls, were cached. A partir de la .NET Framework 2,0, solo se almacenan en caché las expresiones regulares utilizadas en llamadas a métodos estáticos.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

Sin embargo, el almacenamiento en caché puede afectar negativamente al rendimiento en los dos casos siguientes:However, caching can adversely affect performance in the following two cases:

  • Cuando se utilizan llamadas a métodos estáticos con un gran número de expresiones regulares.When you use static method calls with a large number of regular expressions. De forma predeterminada, el motor de expresiones regulares almacena en caché las 15 expresiones regulares estáticas usadas más recientemente.By default, the regular expression engine caches the 15 most recently used static regular expressions. Si la aplicación usa más de 15 expresiones regulares estáticas, se deben volver a compilar algunas expresiones regulares.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. Para evitar esta recompilación, puede aumentar la propiedad Regex.CacheSize.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Al crear una instancia de nuevos objetos Regex con expresiones regulares que se han compilado previamente.When you instantiate new Regex objects with regular expressions that have previously been compiled. Por ejemplo, el código siguiente define una expresión regular para buscar palabras duplicadas en una secuencia de texto.For example, the following code defines a regular expression to locate duplicated words in a text stream. Aunque en el ejemplo se usa una expresión regular única, crea una instancia de un nuevo objeto Regex para procesar cada línea de texto.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Esto da como resultado la recompilación de la expresión regular con cada iteración del bucle.This results in the recompilation of the regular expression with each iteration of the loop.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()   
    

    Para evitar que se vuelvan a compilar, debe crear una instancia de un único Regex objeto que sea accesible para todo el código que lo requiera, tal y como se muestra en el siguiente ejemplo reescrito.To prevent recompilation, you should instantiate a single Regex object that is accessible to all code that requires it, as shown in the following rewritten example.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()   
    

Volver a comentariosBack to Remarks

Realizar operaciones de expresiones regularesPerforming Regular Expression Operations

Tanto si decide crear una instancia de un objeto Regex como llamar a sus métodos o llamar a métodos estáticos, la clase Regex ofrece la siguiente funcionalidad de coincidencia de patrones:Whether you decide to instantiate a Regex object and call its methods or call static methods, the Regex class offers the following pattern-matching functionality:

  • Validación de una coincidencia.Validation of a match. Llame al método IsMatch para determinar si existe una coincidencia.You call the IsMatch method to determine whether a match is present.

  • Recuperación de una sola coincidencia.Retrieval of a single match. Se llama al método Match para recuperar un objeto Match que representa la primera coincidencia en una cadena o en una parte de una cadena.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. Las coincidencias subsiguientes se pueden recuperar llamando al método Match.NextMatch.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Recuperación de todas las coincidencias.Retrieval of all matches. Se llama al método Matches para recuperar un objeto System.Text.RegularExpressions.MatchCollection que representa todas las coincidencias encontradas en una cadena o en una parte de una cadena.You call the Matches method to retrieve a System.Text.RegularExpressions.MatchCollection object that represents all the matches found in a string or in part of a string.

  • Reemplazo del texto coincidente.Replacement of matched text. Llame al método Replace para reemplazar el texto coincidente.You call the Replace method to replace matched text. El texto de reemplazo también se puede definir mediante una expresión regular.The replacement text can also be defined by a regular expression. Además, algunos de los métodos de Replace incluyen un parámetro MatchEvaluator que le permite definir mediante programación el texto de reemplazo.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Creación de una matriz de cadenas que se forma a partir de partes de una cadena de entrada.Creation of a string array that is formed from parts of an input string. Llame al método Split para dividir una cadena de entrada en las posiciones definidas por la expresión regular.You call the Split method to split an input string at positions that are defined by the regular expression.

Además de los métodos de coincidencia de patrones, la clase Regex incluye varios métodos especiales:In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • El método Escape convierte en caracteres de escape los caracteres que se pueden interpretar como operadores de expresiones regulares en una expresión regular o una cadena de entrada.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • El método Unescape quita estos caracteres de escape.The Unescape method removes these escape characters.

  • El método CompileToAssembly crea un ensamblado que contiene expresiones regulares predefinidas.The CompileToAssembly method creates an assembly that contains predefined regular expressions. El .NET Framework contiene ejemplos de estos ensamblados especiales en el espacio de nombres System.Web.RegularExpressions.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Volver a comentariosBack to Remarks

Definir un valor de tiempo de esperaDefining a Time-Out Value

El .NET Framework admite un lenguaje de expresiones regulares con todas las características que proporciona potencia y flexibilidad importantes en la coincidencia de patrones.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. Sin embargo, la eficacia y la flexibilidad suponen un costo: el riesgo de que el rendimiento sea deficiente.However, the power and flexibility come at a cost: the risk of poor performance. Las expresiones regulares que tienen un rendimiento deficiente son sorprendentemente fáciles de crear.Regular expressions that perform poorly are surprisingly easy to create. En algunos casos, puede parecer que las operaciones de expresiones regulares que dependen de un retroceso excesivo pueden dejar de responder cuando procesan texto que casi coincide con el patrón de expresión regular.In some cases, regular expression operations that rely on excessive backtracking can appear to stop responding when they process text that nearly matches the regular expression pattern. Para obtener más información sobre el motor de expresiones regulares .NET Framework, vea detalles del comportamiento de expresiones regulares.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Para obtener más información sobre el retroceso excesivo, vea retroceso.For more information about excessive backtracking, see Backtracking.

A partir de la .NET Framework 4.5.NET Framework 4.5, puede definir un intervalo de tiempo de espera para las coincidencias de expresiones regulares.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. Si el motor de expresiones regulares no puede identificar una coincidencia dentro de este intervalo de tiempo, la operación de búsqueda de coincidencias produce una excepción RegexMatchTimeoutException.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. En la mayoría de los casos, esto evita que el motor de expresiones regulares malgaste la potencia de procesamiento al intentar buscar coincidencias con el texto que casi coincide con el patrón de expresión regular.In most cases, this prevents the regular expression engine from wasting processing power by trying to match text that nearly matches the regular expression pattern. También podría indicar, sin embargo, que el intervalo de tiempo de espera se ha establecido demasiado bajo, o que la carga de la máquina actual ha provocado una degradación general del rendimiento.It also could indicate, however, that the timeout interval has been set too low, or that the current machine load has caused an overall degradation in performance.

La forma en que se controla la excepción depende de la causa de la excepción.How you handle the exception depends on the cause of the exception. Si la excepción se produce porque el intervalo de tiempo de espera es demasiado bajo o porque la carga de la máquina es excesiva, puede aumentar el intervalo de tiempo de espera y reintentar la operación de búsqueda de coincidencias.If the exception occurs because the time-out interval is set too low or because of excessive machine load, you can increase the time-out interval and retry the matching operation. Si la excepción se produce porque la expresión regular se basa en un retroceso excesivo, puede suponer que no existe una coincidencia y, opcionalmente, puede registrar información que le ayude a modificar el patrón de expresión regular.If the exception occurs because the regular expression relies on excessive backtracking, you can assume that a match does not exist, and, optionally, you can log information that will help you modify the regular expression pattern.

Puede establecer un intervalo de tiempo de espera llamando al constructor Regex(String, RegexOptions, TimeSpan) al crear una instancia de un objeto de expresión regular.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. En el caso de los métodos estáticos, puede establecer un intervalo de tiempo de espera llamando a una sobrecarga de un método coincidente que tenga un parámetro matchTimeout.For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. Si no establece explícitamente un valor de tiempo de espera, el valor de tiempo de espera predeterminado se determina de la manera siguiente:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • Mediante el uso del valor de tiempo de espera de toda la aplicación, si existe uno.By using the application-wide time-out value, if one exists. Puede ser cualquier valor de tiempo de espera que se aplique al dominio de aplicación en el que se crea una instancia del objeto Regex o se realiza la llamada al método estático.This can be any time-out value that applies to the application domain in which the Regex object is instantiated or the static method call is made. Puede establecer el valor de tiempo de espera para toda la aplicación llamando al método AppDomain.SetData para asignar la representación de cadena de un valor de TimeSpan a la propiedad "REGEX_DEFAULT_MATCH_TIMEOUT".You can set the application-wide time-out value by calling the AppDomain.SetData method to assign the string representation of a TimeSpan value to the "REGEX_DEFAULT_MATCH_TIMEOUT" property.

  • Utilizando el valor InfiniteMatchTimeout, si no se ha establecido ningún valor de tiempo de espera para toda la aplicación.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Importante

Se recomienda establecer un valor de tiempo de espera en todas las operaciones de coincidencia de patrones de expresión regular.We recommend that you set a time-out value in all regular expression pattern-matching operations. Para obtener más información, vea prácticas recomendadas para las expresiones regulares.For more information, see Best Practices for Regular Expressions.

Volver a comentariosBack to Remarks

Constructores

Regex()

Inicializa una nueva instancia de la clase Regex.Initializes a new instance of the Regex class.

Regex(SerializationInfo, StreamingContext)

Inicializa una nueva instancia de la clase Regex con datos serializados.Initializes a new instance of the Regex class by using serialized data.

Regex(String)

Inicializa una nueva instancia de la clase Regex para la expresión regular especificada.Initializes a new instance of the Regex class for the specified regular expression.

Regex(String, RegexOptions)

Inicializa una nueva instancia de la clase Regex para la expresión regular especificada, con opciones que modifican el modelo.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

Campos

capnames

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

caps

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capsize

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capslist

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

factory

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout

Especifica que una operación de coincidencia de patrones no debe superar el tiempo de espera.Specifies that a pattern-matching operation should not time out.

internalMatchTimeout

Tiempo máximo que puede transcurrir en una operación de coincidencia de patrones antes de que se agote el tiempo de espera de la operación.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

roptions

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

Propiedades

CacheSize

Obtiene o establece el número máximo de entradas en la memoria caché estática actual de expresiones regulares compiladas.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames

Obtiene o establece un diccionario que asigna grupos de captura denominados con sus valores de índice.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps

Obtiene o establece un diccionario que asigna grupos de captura numerados con sus valores de índice.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout

Obtiene el intervalo de tiempo de espera de la instancia actual.Gets the time-out interval of the current instance.

Options

Obtiene las opciones que se pasaron en el constructor Regex.Gets the options that were passed into the Regex constructor.

RightToLeft

Obtiene un valor que indica si la expresión regular busca de derecha a izquierda.Gets a value that indicates whether the regular expression searches from right to left.

Métodos

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Compila uno o varios objetos Regex especificados en un ensamblado con nombre.Compiles one or more specified Regex objects to a named assembly.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Compila uno o varios objetos Regex especificados en un ensamblado con nombre que tiene los atributos especificados.Compiles one or more specified Regex objects to a named assembly with the specified attributes.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Compila uno o varios objetos Regex especificados y un archivo de recursos especificado en un ensamblado con nombre que tiene los atributos indicados.Compiles one or more specified Regex objects and a specified resource file to a named assembly with the specified attributes.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
Escape(String)

Convierte en caracteres de escape un juego mínimo de caracteres (\, *, +, ?, |, {, [, (,), ^, $,., # y espacio en blanco) al reemplazarlos con sus códigos de escape.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. Esto indica al motor de expresiones regulares que interprete los caracteres literalmente en lugar de como metacaracteres.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

Finalize()

Este miembro reemplaza a Finalize(); puede haber documentación más completa en ese tema.This member overrides Finalize(), and more complete documentation might be available in that topic.

Permite que un objeto Object intente liberar recursos y realizar otras operaciones de limpieza antes de que el objeto Object sea reclamado por la recolección de elementos no utilizados.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

GetGroupNames()

Devuelve una matriz de nombres de grupo de captura para la expresión regular.Returns an array of capturing group names for the regular expression.

GetGroupNumbers()

Devuelve una matriz de números de grupo de captura que corresponde a los nombres de grupo en una matriz.Returns an array of capturing group numbers that correspond to group names in an array.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
GroupNameFromNumber(Int32)

Obtiene el nombre de grupo que corresponde al número de grupo especificado.Gets the group name that corresponds to the specified group number.

GroupNumberFromName(String)

Devuelve el número de grupo que corresponde al nombre de grupo especificado.Returns the group number that corresponds to the specified group name.

InitializeReferences()

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

IsMatch(String)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en una cadena de entrada indicada.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

IsMatch(String, Int32)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en la cadena de entrada especificada, empezando en la posición inicial indicada en la cadena.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String)

Indica si la expresión regular especificada busca una coincidencia en la cadena de entrada indicada.Indicates whether the specified regular expression finds a match in the specified input string.

IsMatch(String, String, RegexOptions)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada indicada, utilizando para ello las opciones de coincidencia especificadas.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

IsMatch(String, String, RegexOptions, TimeSpan)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada indicada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se especifiquen.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

Match(String)

Busca en la cadena de entrada especificada la primera aparición de la expresión regular especificada en el constructor Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, Int32)

Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada de la cadena.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String, Int32, Int32)

Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada y buscando solo en el número de caracteres indicado.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String)

Busca en la cadena de entrada especificada la primera aparición de la expresión regular indicada.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions)

Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia indicadas.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, String, RegexOptions, TimeSpan)

Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se indiquen.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Matches(String)

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32)

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular, empezando en la posición de inicio especificada de la cadena.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String)

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular indicada.Searches the specified input string for all occurrences of a specified regular expression.

Matches(String, String, RegexOptions)

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular indicada, utilizando para ello las opciones de coincidencia especificadas.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

Matches(String, String, RegexOptions, TimeSpan)

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular indicada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se especifiquen.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
Replace(String, MatchEvaluator)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32)

En una cadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un modelo de expresión regular por una cadena devuelta por un delegado MatchEvaluator.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32, Int32)

En una subcadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un modelo de expresión regular por una cadena devuelta por un delegado MatchEvaluator.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, String)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32)

En una cadena de entrada especificada, reemplaza un número máximo indicado de cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32, Int32)

En una subcadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, MatchEvaluator)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String, MatchEvaluator, RegexOptions)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Las opciones especificadas modifican la operación de coincidencia.Specified options modify the matching operation.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

En una cadena de entrada especificada, reemplaza todas las subcadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, String, String)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

Replace(String, String, String, RegexOptions)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Las opciones especificadas modifican la operación de coincidencia.Specified options modify the matching operation.

Replace(String, String, String, RegexOptions, TimeSpan)

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un modelo de expresión regular especificado en el constructor Regex.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, Int32)

Divide una cadena de entrada por un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String, Int32, Int32)

Divide una cadena de entrada por un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. La búsqueda del patrón de expresión regular se inicia en la posición de carácter especificada de la cadena de entrada.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Las opciones especificadas modifican la operación de coincidencia.Specified options modify the matching operation.

Split(String, String, RegexOptions, TimeSpan)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

ToString()

Devuelve el modelo de expresión regular que se pasó al constructor Regex.Returns the regular expression pattern that was passed into the Regex constructor.

Unescape(String)

Convierte los caracteres de escape de la cadena de entrada.Converts any escaped characters in the input string.

UseOptionC()

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

UseOptionR()

Lo usa un objeto Regex generado por el método CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

ValidateMatchTimeout(TimeSpan)

Comprueba si un intervalo de tiempo de espera está dentro del intervalo permitido.Checks whether a time-out interval is within an acceptable range.

Implementaciones de interfaz explícitas

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena un objeto SerializationInfo con los datos necesarios para deserializar el objeto Regex actual.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

Se aplica a

Seguridad para subprocesos

La clase Regex es inmutable (de solo lectura) y segura para subprocesos.The Regex class is immutable (read-only) and thread safe. Regex objetos se pueden crear en cualquier subproceso y compartirse entre subprocesos.Regex objects can be created on any thread and shared between threads. Para obtener más información, vea seguridad para subprocesos.For more information, see Thread Safety.

Consulte también: