Regex.Matches Método

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Devoluciones

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

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.

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

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Devoluciones

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

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.

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 .

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

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Devoluciones

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

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.

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

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

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Devoluciones

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

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.

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.

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

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Devoluciones

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

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.

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 .

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(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), que permite especificar el intervalo de tiempo de espera.

Consulte también

• Elementos de lenguaje de expresiones regulares