Regex.Matches Método

Definición

Busca en una cadena de entrada todas las apariciones de una expresión regular y devuelve todas las coincidencias.Searches an input string for all occurrences of a regular expression and returns all the matches.

Sobrecargas

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.

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.

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input);
public System.Text.RegularExpressions.MatchCollection Matches (string input);
member this.Matches : string -> System.Text.RegularExpressions.MatchCollection
Public Function Matches (input As String) As MatchCollection

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

Devoluciones

Colección de los objetos Match encontrados en la búsqueda.A collection of the Match objects found by the search. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.If no matches are found, the method returns an empty collection object.

Excepciones

input es null.input is null.

Ejemplos

En el ejemplo siguiente se Matches(String) usa el método para identificar las palabras de una oración que terminan en "es".The following example uses the Matches(String) method to identify any words in a sentence that end in "es".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes?";
      
      foreach (Match match in rgx.Matches(sentence))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes?"
      
      For Each match As Match In rgx.Matches(sentence)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

El patrón de expresión regular \b\w+es\b se define como se muestra en la tabla siguiente.The regular expression pattern \b\w+es\b is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
es Coincide con la cadena literal "es".Match the literal string "es".
\b Finalizar la búsqueda de coincidencias en un límite de palabras.End the match at a word boundary.

Comentarios

El Matches(String) método es similar al método Match(String) , con la salvedad de que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia.The Matches(String) method is similar to the Match(String) method, except that it returns information about all the matches found in the input string, instead of a single match. Es equivalente al código siguiente:It is equivalent to the following code:

Match match = regex.Match(input);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}  
Dim match As Match = regex.Match(input)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop  

La colección incluye solo las coincidencias y termina en la primera.The collection includes only matches and terminates at the first non-match.

La llamada a uno de los Matches(String) Regex constructores de clase define el patrón de expresión regular para el que busca el método.The regular expression pattern for which the Matches(String) method searches is defined by the call to one of the Regex class constructors. Para obtener más información sobre los elementos que pueden formar un patrón de expresión regular, vea lenguaje de expresiones regulares: referencia rápida.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

El Matches método utiliza la evaluación diferida para rellenar el objeto devuelto. MatchCollectionThe Matches method uses lazy evaluation to populate the returned MatchCollection object. El acceso a los miembros de esta colección MatchCollection.Count como MatchCollection.CopyTo y hace que la colección se rellene inmediatamente.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Para aprovechar las ventajas de la evaluación diferida, debe recorrer foreach en iteración la colección mediante una construcción como en C# y For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext en Visual Basic.in Visual Basic.

Debido a su evaluación diferida, al Matches(String) llamar al método no se RegexMatchTimeoutException produce una excepción.Because of its lazy evaluation, calling the Matches(String) method does not throw a RegexMatchTimeoutException exception. Sin embargo, la excepción se produce cuando se realiza una operación en MatchCollection el objeto devuelto por este método, MatchTimeout si la propiedad Regex.InfiniteMatchTimeout no es y una operación de coincidencia supera el intervalo de tiempo de espera.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if the MatchTimeout property is not Regex.InfiniteMatchTimeout and a matching operation exceeds the time-out interval.

Consulte también:

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.

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, int startat);
public System.Text.RegularExpressions.MatchCollection Matches (string input, int startat);
member this.Matches : string * int -> System.Text.RegularExpressions.MatchCollection
Public Function Matches (input As String, startat As Integer) As MatchCollection

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

startat
Int32

Posición de carácter de la cadena de entrada en la que se va a iniciar la búsqueda.The character position in the input string at which to start the search.

Devoluciones

Colección de los objetos Match encontrados en la búsqueda.A collection of the Match objects found by the search. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.If no matches are found, the method returns an empty collection object.

Excepciones

input es null.input is null.

startat es menor que cero o mayor que la longitud de input.startat is less than zero or greater than the length of input.

Ejemplos

En el ejemplo siguiente se Match(String) usa el método para buscar la primera palabra de una oración que termina en "es" y, a Matches(String, Int32) continuación, llama al método para identificar cualquier palabra adicional que termine en "es".The following example uses the Match(String) method to find the first word in a sentence that ends in "es", and then calls the Matches(String, Int32) method to identify any additional words that end in "es".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes and uses our paper?";
      
      // Get the first match.
      Match match = rgx.Match(sentence);
      if (match.Success) {
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", 
                           match.Value, match.Index);
         // Get any additional matches.
         foreach (Match m in rgx.Matches(sentence, match.Index + match.Length))
            Console.WriteLine("Also found '{0}' at position {1}", 
                              m.Value, m.Index);
      }   
   }
}
// The example displays the following output:
//       Found first 'es' in 'writes' at position 4
//       Also found 'notes' at position 17
//       Also found 'uses' at position 27
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes and uses our paper?"
      
      ' Get the first match.
      Dim match As Match = rgx.Match(sentence)
      If match.Success Then
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", _
                           match.Value, match.Index)
         ' Get any additional matches.
         For Each match In rgx.Matches(sentence, match.Index + match.Length)
            Console.WriteLine("Also found '{0}' at position {1}", _
                              match.Value, match.Index)
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Found first 'es' in 'writes' at position 4
'       Also found 'notes' at position 17
'       Also found 'uses' at position 27

El patrón de expresión regular \b\w+es\b se define como se muestra en la tabla siguiente.The regular expression pattern \b\w+es\b is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
es Coincide con la cadena literal "es".Match the literal string "es".
\b Finalizar la búsqueda de coincidencias en un límite de palabras.End the match at a word boundary.

Comentarios

El Matches(String, Int32) método es similar al método Match(String, Int32) , con la salvedad de que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia.The Matches(String, Int32) method is similar to the Match(String, Int32) method, except that it returns information about all the matches found in the input string, instead of a single match. Es equivalente al código siguiente:It is equivalent to the following code:

Match match = regex.Match(input, startAt);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}  
Dim match As Match = regex.Match(input, startAt)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop  

La llamada a uno de los Matches(String, Int32) Regex constructores de clase define el patrón de expresión regular para el que busca el método.The regular expression pattern for which the Matches(String, Int32) method searches is defined by the call to one of the Regex class constructors. Para obtener más información sobre los elementos que pueden formar un patrón de expresión regular, vea lenguaje de expresiones regulares: referencia rápida.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

El Matches método utiliza la evaluación diferida para rellenar el objeto devuelto. MatchCollectionThe Matches method uses lazy evaluation to populate the returned MatchCollection object. El acceso a los miembros de esta colección MatchCollection.Count como MatchCollection.CopyTo y hace que la colección se rellene inmediatamente.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Para aprovechar las ventajas de la evaluación diferida, debe recorrer foreach en iteración la colección mediante una construcción como en C# y For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext en Visual Basic.in Visual Basic.

Debido a su evaluación diferida, al Matches(String, Int32) llamar al método no se RegexMatchTimeoutException produce una excepción.Because of its lazy evaluation, calling the Matches(String, Int32) method does not throw a RegexMatchTimeoutException exception. Sin embargo, la excepción se produce cuando se realiza una operación en MatchCollection el objeto devuelto por este método, MatchTimeout si la propiedad Regex.InfiniteMatchTimeout no es y una operación de coincidencia supera el intervalo de tiempo de espera.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if the MatchTimeout property is not Regex.InfiniteMatchTimeout and a matching operation exceeds the time-out interval.

Consulte también:

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.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern);
static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String) As MatchCollection

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.The regular expression pattern to match.

Devoluciones

Colección de los objetos Match encontrados en la búsqueda.A collection of the Match objects found by the search. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.If no matches are found, the method returns an empty collection object.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

input o pattern es null.input or pattern is null.

Ejemplos

En el ejemplo siguiente se Matches(String, String) usa el método para identificar cualquier palabra de una oración que termina en "es".The following example uses the Matches(String, String) method to identify any word in a sentence that ends in "es".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "Who writes these notes?";
      
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "Who writes these notes?"
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

El patrón de expresión regular \b\w+es\b se define como se muestra en la tabla siguiente.The regular expression pattern \b\w+es\b is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
es Coincide con la cadena literal "es".Match the literal string "es".
\b Finalizar la búsqueda de coincidencias en un límite de palabras.End the match at a word boundary.

Comentarios

El Matches(String, String) método es similar al método Match(String, String) , con la salvedad de que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia.The Matches(String, String) method is similar to the Match(String, String) method, except that it returns information about all the matches found in the input string, instead of a single match. Es equivalente al código siguiente:It is equivalent to the following code:

Match match = Regex.Match(input, pattern);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}  
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop  

Los métodos Matches estáticos son equivalentes a construir Regex un objeto con el patrón de expresión regular especificado y llamar al Matchesmétodo de instancia.The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

El pattern parámetro se compone de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El Matches método utiliza la evaluación diferida para rellenar el objeto devuelto. MatchCollectionThe Matches method uses lazy evaluation to populate the returned MatchCollection object. El acceso a los miembros de esta colección MatchCollection.Count como MatchCollection.CopyTo y hace que la colección se rellene inmediatamente.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Para aprovechar las ventajas de la evaluación diferida, debe recorrer foreach en iteración la colección mediante una construcción como en C# y For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext en Visual Basic.in Visual Basic.

Debido a su evaluación diferida, al Matches(String, String) llamar al método no se RegexMatchTimeoutException produce una excepción.Because of its lazy evaluation, calling the Matches(String, String) method does not throw a RegexMatchTimeoutException exception. Sin embargo, la excepción se produce cuando se realiza una operación en MatchCollection el objeto devuelto por este método, si un intervalo de tiempo de espera se define mediante la propiedad "REGEX_DEFAULT_MATCH_TIMEOUT" del dominio de aplicación actual y una operación coincidente. supera este intervalo de tiempo de espera.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if a time-out interval is defined by the "REGEX_DEFAULT_MATCH_TIMEOUT" property of the current application domain and a matching operation exceeds this time-out interval.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, InfiniteMatchTimeoutse utiliza el valor, que impide que se agote el tiempo de espera del método.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para recuperar varias coincidencias de Matches(String, String, RegexOptions, TimeSpan)patrón es, que permite especificar el intervalo de tiempo de espera.The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you specify the time-out interval.

Consulte también:

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.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String, options As RegexOptions) As MatchCollection

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.The regular expression pattern to match.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que especifican opciones de coincidencia.A bitwise combination of the enumeration values that specify options for matching.

Devoluciones

Colección de los objetos Match encontrados en la búsqueda.A collection of the Match objects found by the search. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.If no matches are found, the method returns an empty collection object.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

options no es una combinación bit a bit válida de valores RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Ejemplos

En el ejemplo siguiente se Matches(String, String) llama al método para identificar cualquier palabra de una oración que termina en "es" y, a Matches(String, String, RegexOptions) continuación, llama al método para realizar una comparación sin distinción entre mayúsculas y minúsculas del patrón con la cadena de entrada.The following example calls the Matches(String, String) method to identify any word in a sentence that ends in "es", and then calls the Matches(String, String, RegexOptions) method to perform a case-insensitive comparison of the pattern with the input string. Como se muestra en el resultado, los dos métodos devuelven resultados diferentes.As the output shows, the two methods return different results.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      For Each match As Match In Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

El patrón de expresión regular \b\w+es\b se define como se muestra en la tabla siguiente.The regular expression pattern \b\w+es\b is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
es Coincide con la cadena literal "es".Match the literal string "es".
\b Finalizar la búsqueda de coincidencias en un límite de palabras.End the match at a word boundary.

Comentarios

El Matches(String, String, RegexOptions) método es similar al método Match(String, String, RegexOptions) , con la salvedad de que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia.The Matches(String, String, RegexOptions) method is similar to the Match(String, String, RegexOptions) method, except that it returns information about all the matches found in the input string, instead of a single match. Es equivalente al código siguiente:It is equivalent to the following code:

Match match = Regex.Match(input, pattern, options);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}  
Dim match As Match = Regex.Match(input, pattern, options)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop  

Los métodos Matches estáticos son equivalentes a construir Regex un objeto con el patrón de expresión regular especificado y llamar al Matchesmétodo de instancia.The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

El pattern parámetro se compone de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El Matches método utiliza la evaluación diferida para rellenar el objeto devuelto. MatchCollectionThe Matches method uses lazy evaluation to populate the returned MatchCollection object. El acceso a los miembros de esta colección MatchCollection.Count como MatchCollection.CopyTo y hace que la colección se rellene inmediatamente.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Para aprovechar las ventajas de la evaluación diferida, debe recorrer foreach en iteración la colección mediante una construcción como en C# y For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext en Visual Basic.in Visual Basic.

Debido a su evaluación diferida, al Matches(String, String) llamar al método no se RegexMatchTimeoutException produce una excepción.Because of its lazy evaluation, calling the Matches(String, String) method does not throw a RegexMatchTimeoutException exception. Sin embargo, la excepción se produce cuando se realiza una operación en MatchCollection el objeto devuelto por este método, si un intervalo de tiempo de espera se define mediante la propiedad "REGEX_DEFAULT_MATCH_TIMEOUT" del dominio de aplicación actual y una operación coincidente. supera este intervalo de tiempo de espera.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if a time-out interval is defined by the "REGEX_DEFAULT_MATCH_TIMEOUT" property of the current application domain and a matching operation exceeds this time-out interval.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, InfiniteMatchTimeoutse utiliza el valor, que impide que se agote el tiempo de espera del método.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para recuperar varias coincidencias de Matches(String, String, RegexOptions, TimeSpan)patrón es, que permite establecer el intervalo de tiempo de espera.The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consulte también:

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.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Matches : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As MatchCollection

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.The regular expression pattern to match.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que especifican opciones de coincidencia.A bitwise combination of the enumeration values that specify options for matching.

matchTimeout
TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Devoluciones

Colección de los objetos Match encontrados en la búsqueda.A collection of the Match objects found by the search. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.If no matches are found, the method returns an empty collection object.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

options no es una combinación bit a bit válida de valores RegexOptions .options is not a valid bitwise combination of RegexOptions values.

o bien-or- matchTimeout es negativo, cero o mayor que 24 días aproximadamente.matchTimeout is negative, zero, or greater than approximately 24 days.

Ejemplos

En el ejemplo siguiente se Matches(String, String, RegexOptions, TimeSpan) llama al método para realizar una comparación que distingue entre mayúsculas y minúsculas y que coincide con cualquier palabra de una oración que termina en "es".The following example calls the Matches(String, String, RegexOptions, TimeSpan) method to perform a case-sensitive comparison that matches any word in a sentence that ends in "es". A continuación, llama Matches(String, String, RegexOptions, TimeSpan) al método para realizar una comparación sin distinción entre mayúsculas y minúsculas del patrón con la cadena de entrada.It then calls the Matches(String, String, RegexOptions, TimeSpan) method to perform a case-insensitive comparison of the pattern with the input string. En ambos casos, el intervalo de tiempo de espera se establece en un segundo.In both cases, the time-out interval is set to one second. Como se muestra en el resultado, los dos métodos devuelven resultados diferentes.As the output shows, the two methods return different results.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      try {
         foreach (Match match in Regex.Matches(sentence, pattern,
                                               RegexOptions.None,
                                               TimeSpan.FromSeconds(1)))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {
         // Do Nothing: Assume that timeout represents no match.
      }
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      try { 
         foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {}
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern, 
                                               RegexOptions.None, 
                                               TimeSpan.FromSeconds(1))
         Try
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Catch e As RegexMatchTimeoutException
            ' Do Nothing: Assume that timeout represents no match.
         End Try
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      Try
         For Each match As Match In Regex.Matches(sentence, pattern, 
                                                  RegexOptions.IgnoreCase,
                                                  TimeSpan.FromSeconds(1))
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Next
      Catch de As RegexMatchTimeoutException
         ' Do Nothing: Assume that timeout represents no match.
      End Try
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

El patrón de expresión regular \b\w+es\b se define como se muestra en la tabla siguiente.The regular expression pattern \b\w+es\b is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
es Coincide con la cadena literal "es".Match the literal string "es".
\b Finalizar la búsqueda de coincidencias en un límite de palabras.End the match at a word boundary.

Comentarios

El Matches(String, String, RegexOptions, TimeSpan) método es similar al método Match(String, String, RegexOptions, TimeSpan) , con la salvedad de que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia.The Matches(String, String, RegexOptions, TimeSpan) method is similar to the Match(String, String, RegexOptions, TimeSpan) method, except that it returns information about all the matches found in the input string, instead of a single match. Es equivalente al código siguiente:It is equivalent to the following code:

   try {
      Match match = Regex.Match(input, pattern, options,
                                TimeSpan.FromSeconds(1));
      while (match.Success) {
            // Handle match here...

            match = match.NextMatch();
      }  
   }
   catch (RegexMatchTimeoutException) {
      // Do nothing: assume that exception represents no match.
   }
   Try
      Dim match As Match = Regex.Match(input, pattern, options, 
                                       TimeSpan.FromSeconds(1))
      Do While match.Success
            ' Handle match here...

            match = match.NextMatch()
      Loop  
   Catch e As RegexMatchTimeoutException
      ' Do nothing: assume that exception represents no match.
   End Try   

Los métodos Matches estáticos son equivalentes a construir Regex un objeto con el patrón de expresión regular especificado y llamar al Matchesmétodo de instancia.The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

El pattern parámetro se compone de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El Matches método utiliza la evaluación diferida para rellenar el objeto devuelto. MatchCollectionThe Matches method uses lazy evaluation to populate the returned MatchCollection object. El acceso a los miembros de esta colección MatchCollection.Count como MatchCollection.CopyTo y hace que la colección se rellene inmediatamente.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Para aprovechar las ventajas de la evaluación diferida, debe recorrer foreach en iteración la colección mediante una construcción como en C# y For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext en Visual Basic.in Visual Basic.

Debido a su evaluación diferida, al Matches llamar al método no se RegexMatchTimeoutException produce una excepción.Because of its lazy evaluation, calling the Matches method does not throw a RegexMatchTimeoutException exception. Sin embargo, se produce una excepción cuando se realiza una operación en MatchCollection el objeto devuelto por este método, si una operación de búsqueda de coincidencias supera estematchTimeout intervalo de tiempo de espera especificado por el parámetro.However, an exception is thrown when an operation is performed on the MatchCollection object returned by this method, if a matching operation exceeds this time-out interval specified by thematchTimeout parameter.

Notas a los autores de las llamadas

Se recomienda establecer el matchTimeout parámetro en un valor adecuado, como dos segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si se deshabilitan los tiempos de espera InfiniteMatchTimeoutespecificados, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Sin embargo, solo debe deshabilitar los tiempos de espera en las siguientes condiciones:However, you should disable time-outs only under the following conditions: : Cuando la entrada procesada por una expresión regular se deriva de una fuente conocida y de confianza o está formada por texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Esto excluye el texto que los usuarios han introducido dinámicamente.This excludes text that has been dynamically input by users.

-Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla de forma eficaz las coincidencias, las no coincidencias y las coincidencias cercanas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que producen un retroceso excesivo al procesar una coincidencia cercana.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Consulte también:

Se aplica a