Regex Regex Regex Regex Class

Definición

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

public ref 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
RegexRegexRegexRegex
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se usa una expresión regular para comprobar las 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.

ModeloPattern DescripciónDescription
\b Comenzar la búsqueda de coincidencias en un límite de palabras.Start the match at a word boundary.
(?<word>\w+) Coincide con uno o más caracteres de palabra hasta un límite de palabras.Match one or more word characters up to a word boundary. Nombre de este grupo capturado 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 denominada 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
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

El ejemplo siguiente muestra el uso de una expresión regular para comprobar si una cadena representa un valor de divisa 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, se genera dinámicamente la expresión regular de la NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, y NumberFormatInfo.PositiveSign las propiedades de la referencia cultural 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 el sistema actual de la referencia cultural 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.

ModeloPattern DescripciónDescription
^ Comience desde el 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 aparició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 con cero o una vez de 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 se da por supuesto que una cadena de divisa válida no contiene símbolos de separador de grupo y que tiene ningún dígito fraccionario o el número de dígitos fraccionarios definido por la referencia cultural actual CurrencyDecimalDigits propiedad.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 en este ejemplo se genera dinámicamente, no sabemos en tiempo de diseño si el símbolo de divisa de la referencia cultural actual, signo decimal o signos positivos y negativos se pueden malinterpretar por el motor de expresiones regulares como normales operadores de lenguaje de expresión.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 los errores de interpretación, el ejemplo pasa cada cadena generada dinámicamente a la Escape método.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Comentarios

La Regex clase representa el motor de expresiones regulares de .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, editar, 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 consiste en validar una cadena mediante la determinación de si se ajusta a un patrón determinado, puede usar el System.Configuration.RegexStringValidator clase.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 modelo que desea identificar en una secuencia de texto utilizando la sintaxis documentada en lenguaje de expresiones regulares - referencia rápida.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, opcionalmente, crear instancias de un Regex objeto.Next, you can optionally instantiate a Regex object. Por último, llamar a un método que realiza alguna operación, como reemplazar texto que coincide con el patrón de expresión regular, o que identifica a una coincidencia de patrones.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 algunos patrones de expresiones regulares comunes, consulte ejemplos de expresiones regulares.For some common regular expression patterns, see Regular Expression Examples. También hay una serie de bibliotecas en línea de patrones de expresiones regulares, como el de uno en -expresiones regulares.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 Regex de clases, vea las secciones siguientes 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 de vs. Métodos StringRegex vs. String Methods

La System.String clase incluye varios métodos de búsqueda y comparación que puede usar para realizar la coincidencia de patrones con texto.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Por ejemplo, el String.Contains, String.EndsWith, y String.StartsWith métodos determinan si una instancia de la cadena contiene una subcadena especificada; y la String.IndexOf, String.IndexOfAny, String.LastIndexOf, y String.LastIndexOfAny métodos devuelven la fecha inicial posición 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 System.String al buscar una cadena específica de la clase.Use the methods of the System.String class when you are searching for a specific string. Use la Regex clase cuando se está buscando 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 expresiones regulares de .NET Framework.For more information and examples, see .NET Framework Regular Expressions.

Volver a comentariosBack to Remarks

Puertos estáticos frente a. Métodos de instanciaStatic vs. Instance Methods

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

  • Creando un Regex objeto 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 una Regex constructor.To do this, you pass the regular expression pattern to a Regex constructor. Un Regex objeto es inmutable; al crear una instancia un Regex objeto con una expresión regular, que no se puede cambiar la expresión regular del objeto.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Si se suministra la expresión regular y el texto que desea 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 Regex objeto.This enables you to use a regular expression without explicitly creating a Regex object.

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

El motor de expresiones regulares debe compilar un modelo determinado antes de que se puede usar el patrón.The regular expression engine must compile a particular pattern before the pattern can be used. Dado que Regex los objetos son inmutables, se trata de un procedimiento único que se produce cuando un Regex se denomina constructor de clase o 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 única expresión regular, el motor de expresiones regulares almacena en caché las expresiones regulares compiladas que se utilizan en 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 patrón de expresión regular ofrecen un rendimiento comparable para estáticos y métodos de instancia.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Importante

Si se usaron en la instancia o método estático en las expresiones regulares de .NET Framework versiones 1.0 y 1.1, todos los compilados, llama a, 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 .NET Framework 2.0, solo las expresiones regulares usadas en llamadas a métodos estáticos se almacenan en caché.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:

  • Al utilizar 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 que esta recompilación, puede aumentar el Regex.CacheSize propiedad.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Cuando se crea una instancia nueva Regex objetos 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 el ejemplo utiliza una expresión regular única, crea una instancia de un nuevo Regex objeto 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 volver a compilar, debe crear una instancia de una sola Regex objeto que es accesible a todo el código que lo requiera, como se muestra en el ejemplo siguiente se ha vuelto a escribir.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

Si decide crear una instancia de un Regex de objeto y llamar a sus métodos o llamar a métodos estáticos, el Regex clase ofrece las siguientes funciones 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. Se llama a la IsMatch método para determinar si se encuentra una coincidencia.You call the IsMatch method to determine whether a match is present.

  • Recuperación de una coincidencia única.Retrieval of a single match. Se llama a la Match método para recuperar un Match objeto que representa la primera coincidencia en una cadena o en 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. Se pueden recuperar las coincidencias subsiguientes llamando el Match.NextMatch método.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Recuperación de todas las coincidencias.Retrieval of all matches. Se llama a la Matches método para recuperar un System.Text.RegularExpressions.MatchCollection objeto que representa todas las coincidencias encontradas en una cadena o en 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.

  • Sustitución del texto coincidente.Replacement of matched text. Se llama a la Replace método para reemplazar el texto coincidente.You call the Replace method to replace matched text. El texto de reemplazo también puede definirse mediante una expresión regular.The replacement text can also be defined by a regular expression. Además, algunos de los Replace métodos incluyen un MatchEvaluator parámetro 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. Se llama a la Split método 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 sus métodos de coincidencia de patrones, el Regex clase incluye varios métodos de propósito especial:In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • El Escape método escapes de caracteres que se pueden interpretar como operadores de expresión regular 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 Unescape método quita estos caracteres de escape.The Unescape method removes these escape characters.

  • El CompileToAssembly método crea un ensamblado que contiene expresiones regulares predefinidas.The CompileToAssembly method creates an assembly that contains predefined regular expressions. .NET Framework contiene ejemplos de estos ensamblados de propósito especial en el System.Web.RegularExpressions espacio de nombres.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

.NET Framework admite un lenguaje de expresión regular completa que proporciona sustancial eficacia y flexibilidad 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 flexibilidad vienen con cierto costo: el riesgo de un rendimiento deficiente.However, the power and flexibility come at a cost: the risk of poor performance. Las expresiones regulares que un rendimiento deficiente son sorprendentemente fáciles de crear.Regular expressions that perform poorly are surprisingly easy to create. En algunos casos, las operaciones de expresión regular que se basan en el retroceso excesivo pueden aparecer deje de responder cuando procesa el 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 de .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, consulte 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 coincidencia produce un RegexMatchTimeoutException excepción.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 impide que el motor de expresiones regulares desperdiciar potencia de procesamiento al tratar de coincidir 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 actual de la máquina ha causado 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.

Cómo controlar 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 se establece demasiado bajo, o debido a la carga de la máquina excesivo, puede aumentar el intervalo de tiempo de espera y vuelva a intentar la operación de coincidencia.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 ayudarán 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 mediante una llamada a la Regex(String, RegexOptions, TimeSpan) constructor al crear instancias 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. Para los métodos estáticos, puede establecer un intervalo de tiempo de espera mediante una llamada a una sobrecarga de un método coincidente que tenga un matchTimeout parámetro.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 como sigue:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • Utilizando el tiempo de espera de toda la aplicación el valor, si existe.By using the application-wide time-out value, if one exists. Esto puede ser cualquier valor de tiempo de espera que se aplica al dominio de aplicación en el que el Regex se crea una instancia de objeto 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 de toda la aplicación mediante una llamada a la AppDomain.SetData método para asignar una representación de cadena de un TimeSpan valor 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.

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

Importante

Se recomienda que establezca un valor de tiempo de espera en todas las operaciones de coincidencia de patrones de expresiones regulares.We recommend that you set a time-out value in all regular expression pattern-matching operations. Para obtener más información, consulte procedimientos recomendados con expresiones regulares.For more information, see Best Practices for Regular Expressions.

Volver a comentariosBack to Remarks

Constructores

Regex() Regex() Regex() Regex()

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

Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) 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) Regex(String) Regex(String) 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) Regex(String, RegexOptions) Regex(String, RegexOptions) 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) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) 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 capnames capnames capnames

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

caps caps caps caps

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

capsize capsize capsize capsize

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

capslist capslist capslist capslist

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

factory factory factory factory

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

InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout 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 internalMatchTimeout internalMatchTimeout 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 pattern pattern pattern

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

roptions roptions roptions roptions

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

Propiedades

CacheSize CacheSize CacheSize 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 CapNames CapNames 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 Caps Caps 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 MatchTimeout MatchTimeout MatchTimeout

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

Options Options Options Options

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

RightToLeft RightToLeft RightToLeft 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) CompileToAssembly(RegexCompilationInfo[], AssemblyName) CompileToAssembly(RegexCompilationInfo[], AssemblyName) 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[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) 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) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) 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) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
Escape(String) Escape(String) Escape(String) 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() Finalize() Finalize() 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() GetGroupNames() GetGroupNames() 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() GetGroupNumbers() GetGroupNumbers() 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() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetType() GetType() GetType() GetType()

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

(Inherited from Object)
GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) 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) GroupNumberFromName(String) GroupNumberFromName(String) 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() InitializeReferences() InitializeReferences() InitializeReferences()

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

IsMatch(String) IsMatch(String) IsMatch(String) 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) IsMatch(String, Int32) IsMatch(String, Int32) 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) IsMatch(String, String) IsMatch(String, 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) IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions) 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) IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan) 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) Match(String) Match(String) 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) Match(String, Int32) Match(String, Int32) 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) Match(String, Int32, Int32) Match(String, Int32, Int32) 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) Match(String, String) Match(String, String) 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) Match(String, String, RegexOptions) Match(String, String, RegexOptions) 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) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) 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) Matches(String) Matches(String) 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) Matches(String, Int32) Matches(String, Int32) 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) Matches(String, String) Matches(String, 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) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) 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) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) 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() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) 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) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) 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) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) 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) Replace(String, String) Replace(String, String) 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) Replace(String, String, Int32) Replace(String, String, Int32) 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) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) 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) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) 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) Replace(String, String, MatchEvaluator, RegexOptions) Replace(String, String, MatchEvaluator, RegexOptions) 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) Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) 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) Replace(String, String, String) Replace(String, String, String) 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) Replace(String, String, String, RegexOptions) Replace(String, String, String, RegexOptions) 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) Replace(String, String, String, RegexOptions, TimeSpan) Replace(String, String, String, RegexOptions, TimeSpan) 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) Split(String) Split(String) 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) Split(String, Int32) Split(String, Int32) 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) Split(String, Int32, Int32) Split(String, Int32, Int32) 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) Split(String, String) Split(String, 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) Split(String, String, RegexOptions) Split(String, String, RegexOptions) 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) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) 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() ToString() ToString() 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) Unescape(String) Unescape(String) Unescape(String)

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

UseOptionC() UseOptionC() UseOptionC() UseOptionC()

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

UseOptionR() UseOptionR() UseOptionR() UseOptionR()

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

ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) 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) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) 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 Regex clase es inmutable (de solo lectura) y es seguro para subprocesos.The Regex class is immutable (read-only) and thread safe. Regex los objetos se pueden crear en cualquier subproceso y compartirlos entre varios subprocesos.Regex objects can be created on any thread and shared between threads. Para obtener más información, consulte Thread Safety.For more information, see Thread Safety.

Consulte también: