Regex.Matches Método

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Busca en una cadena de entrada todas las apariciones de una expresión regular y devuelve todas las coincidencias.

Sobrecargas

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.
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.
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.
Matches(String)	Busca en la cadena de entrada especificada todas las apariciones de una expresión regular.
Matches(String, String)	Busca en la cadena de entrada especificada todas las apariciones de una expresión regular indicada.

Matches(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

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.

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.

pattern: String

Patrón de expresión regular del que van a buscarse coincidencias.

options: RegexOptions

Combinación bit a bit de los valores de enumeración que especifican opciones de coincidencia.

matchTimeout: TimeSpan

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

Devoluciones

MatchCollection

Colección de los objetos Match encontrados en la búsqueda. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.

Excepciones

ArgumentException

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

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de valores RegexOptions.

O bien

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

Ejemplos

En el ejemplo siguiente se llama al Matches(String, String, RegexOptions, TimeSpan) método para realizar una comparación que distingue mayúsculas de minúsculas que coincide con cualquier palabra de una oración que termina en "es". A continuación, llama al Matches(String, String, RegexOptions, TimeSpan) método para realizar una comparación sin distinción entre mayúsculas y minúsculas del patrón con la cadena de entrada. En ambos casos, el intervalo de tiempo de espera se establece en un segundo. Como se muestra en la salida, los dos métodos devuelven resultados diferentes.

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.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`\w+`	Buscar coincidencias con uno o más caracteres alfabéticos.
`es`	Coincide con la cadena literal "es".
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Matches(String, String, RegexOptions, TimeSpan) método es similar al Match(String, String, RegexOptions, TimeSpan) método , salvo que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia. Es equivalente al código siguiente:

   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 estáticos Matches son equivalentes a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método Matchesde instancia .

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida.

El Matches método usa la evaluación diferida para rellenar el objeto devuelto MatchCollection . El acceso a los miembros de esta colección como MatchCollection.Count y MatchCollection.CopyTo hace que la colección se rellene inmediatamente. Para aprovechar la evaluación diferida, debe iterar la colección mediante una construcción como foreach en C# y For Each...Next en Visual Basic.

Debido a su evaluación diferida, al llamar al Matches método no se produce una RegexMatchTimeoutException excepción. Sin embargo, se produce una excepción cuando se realiza una operación en el MatchCollection objeto devuelto por este método, si una operación coincidente supera este intervalo de tiempo de espera especificado por elmatchTimeout parámetro .

Notas a los autores de las llamadas

Se recomienda establecer el matchTimeout parámetro en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.
Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.
Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

Elementos de lenguaje de expresiones regulares

Se aplica a

Matches(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular indicada, utilizando para ello las opciones de coincidencia especificadas.

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.

pattern: String

Patrón de expresión regular del que van a buscarse coincidencias.

options: RegexOptions

Combinación bit a bit de los valores de enumeración que especifican opciones de coincidencia.

Devoluciones

MatchCollection

Colección de los objetos Match encontrados en la búsqueda. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.

Excepciones

ArgumentException

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

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de valores RegexOptions.

Ejemplos

En el ejemplo siguiente se llama al Matches(String, String) método para identificar cualquier palabra de una oración que termina en "es" y, a continuación, llama al Matches(String, String, RegexOptions) método para realizar una comparación sin distinción entre mayúsculas y minúsculas del patrón con la cadena de entrada. Como se muestra en la salida, los dos métodos devuelven resultados diferentes.

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.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`\w+`	Buscar coincidencias con uno o más caracteres alfabéticos.
`es`	Coincide con la cadena literal "es".
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Matches(String, String, RegexOptions) método es similar al Match(String, String, RegexOptions) método , salvo que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia. Es equivalente al código siguiente:

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 estáticos Matches son equivalentes a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método Matchesde instancia .

Debido a su evaluación diferida, al llamar al Matches(String, String) método no se produce una RegexMatchTimeoutException excepción. Sin embargo, la excepción se produce cuando se realiza una operación en el MatchCollection objeto devuelto por este método, si se define un intervalo de tiempo de espera por la propiedad "REGEX_DEFAULT_MATCH_TIMEOUT" del dominio de aplicación actual y una operación coincidente supera este intervalo de tiempo de espera.

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. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para recuperar varias coincidencias de patrones es Matches(String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Elementos de lenguaje de expresiones regulares

Se aplica a

Matches(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

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.

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.

startat: Int32

Posición de carácter de la cadena de entrada en la que se va a iniciar la búsqueda.

Devoluciones

MatchCollection

Colección de los objetos Match encontrados en la búsqueda. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.

Excepciones

ArgumentNullException

input es null.

ArgumentOutOfRangeException

startat es menor que cero o mayor que la longitud de input.

Ejemplos

En el ejemplo siguiente se usa el Match(String) método para buscar la primera palabra de una frase que termina en "es" y, a continuación, se llama al Matches(String, Int32) método para identificar las palabras adicionales que terminan en "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.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`\w+`	Buscar coincidencias con uno o más caracteres alfabéticos.
`es`	Coincide con la cadena literal "es".
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Matches(String, Int32) método es similar al Match(String, Int32) método , salvo que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia. Es equivalente al código siguiente:

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

El patrón de expresión regular para el que el Matches(String, Int32) método busca se define mediante la llamada a uno de los Regex constructores de clase. 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.

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

Debido a su evaluación diferida, al llamar al Matches(String, Int32) método no se produce una RegexMatchTimeoutException excepción. Sin embargo, la excepción se produce cuando se realiza una operación en el MatchCollection objeto devuelto por este método, si la MatchTimeout propiedad no Regex.InfiniteMatchTimeout es y una operación coincidente supera el intervalo de tiempo de espera.

Consulte también

Elementos de lenguaje de expresiones regulares

Se aplica a

Matches(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular.

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.

Devoluciones

MatchCollection

Colección de los objetos Match encontrados en la búsqueda. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.

Excepciones

ArgumentNullException

input es null.

Ejemplos

En el ejemplo siguiente se usa el Matches(String) método para identificar las palabras de una oración que terminan en "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.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`\w+`	Buscar coincidencias con uno o más caracteres alfabéticos.
`es`	Coincide con la cadena literal "es".
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Matches(String) método es similar al Match(String) método , salvo que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia. Es equivalente al código siguiente:

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 solo incluye coincidencias y termina en la primera no coincidencia.

El patrón de expresión regular para el que el Matches(String) método busca se define mediante la llamada a uno de los Regex constructores de clase. 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.

Debido a su evaluación diferida, al llamar al Matches(String) método no se produce una RegexMatchTimeoutException excepción. Sin embargo, la excepción se produce cuando se realiza una operación en el MatchCollection objeto devuelto por este método, si la MatchTimeout propiedad no Regex.InfiniteMatchTimeout es y una operación coincidente supera el intervalo de tiempo de espera.

Consulte también

Elementos de lenguaje de expresiones regulares

Se aplica a

Matches(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada especificada todas las apariciones de una expresión regular indicada.

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.

pattern: String

Patrón de expresión regular del que van a buscarse coincidencias.

Devoluciones

MatchCollection

Colección de los objetos Match encontrados en la búsqueda. Si no se encuentran coincidencias, el método devuelve un objeto de colección vacía.

Excepciones

ArgumentException

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

ArgumentNullException

input o pattern es null.

Ejemplos

En el ejemplo siguiente se usa el Matches(String, String) método para identificar cualquier palabra de una oración que termine en "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.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`\w+`	Buscar coincidencias con uno o más caracteres alfabéticos.
`es`	Coincide con la cadena literal "es".
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Matches(String, String) método es similar al Match(String, String) método , salvo que devuelve información sobre todas las coincidencias encontradas en la cadena de entrada, en lugar de una sola coincidencia. Es equivalente al código siguiente:

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 estáticos Matches son equivalentes a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método Matchesde instancia .

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. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para recuperar varias coincidencias de patrones es Matches(String, String, RegexOptions, TimeSpan), que permite especificar el intervalo de tiempo de espera.

Consulte también

Elementos de lenguaje de expresiones regulares

Se aplica a

Compartir a través de

Regex.Matches Método

Definición

Sobrecargas

Matches(String, String, RegexOptions, TimeSpan)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Matches(String, String, RegexOptions)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Matches(String, Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Matches(String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Matches(String, String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Recursos adicionales