Regex.Matches Método

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Pesquisa em uma cadeia de caracteres de entrada todas as ocorrências de uma expressão regular e retorna todas as correspondências.

Sobrecargas

Matches(String, String, RegexOptions, TimeSpan)	Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas e o intervalo de tempo limite.
Matches(String, String, RegexOptions)	Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas.
Matches(String, Int32)	Pesquisa a cadeia de caracteres de entrada especificada para todas as ocorrências de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.
Matches(String)	Pesquisa todas as ocorrências de uma expressão regular na cadeia de caracteres de entrada especificada.
Matches(String, String)	Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de entrada especificada.

Matches(String, String, RegexOptions, TimeSpan)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas e o intervalo de tempo limite.

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

A cadeia de caracteres na qual será pesquisada uma correspondência.

pattern: String

O padrão de expressão regular para correspondência.

options: RegexOptions

Uma combinação bit a bit dos valores de enumeração que especifica opções para correspondência.

matchTimeout: TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.

Retornos

MatchCollection

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

ArgumentException

Ocorreu um erro de análise da expressão regular.

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores de RegexOptions.

- ou -

matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

Exemplos

O exemplo a seguir chama o Matches(String, String, RegexOptions, TimeSpan) método para executar uma comparação que diferencia maiúsculas de minúsculas que corresponda a qualquer palavra em uma frase que termine em "es". Em seguida, ele chama o Matches(String, String, RegexOptions, TimeSpan) método para executar uma comparação que não diferencia maiúsculas de minúsculas do padrão com a cadeia de caracteres de entrada. Em ambos os casos, o intervalo de tempo limite é definido como um segundo. Como mostra a saída, os dois métodos retornam 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

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`\w+`	Fazer a correspondência a um ou mais caracteres de palavra.
`es`	Corresponde à cadeia de caracteres literal "es".
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Matches(String, String, RegexOptions, TimeSpan) método é semelhante ao Match(String, String, RegexOptions, TimeSpan) método , exceto que ele retorna informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

   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

Os métodos estáticos Matches são equivalentes a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método Matchesde instância .

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte Expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

O Matches método usa a avaliação lenta para preencher o objeto retornado MatchCollection . Acessar membros dessa coleção como MatchCollection.Count e MatchCollection.CopyTo faz com que a coleção seja preenchida imediatamente. Para aproveitar a avaliação lenta, você deve iterar a coleção usando um constructo como foreach em C# e For Each...Next no Visual Basic.

Devido à avaliação lenta, chamar o Matches método não gera uma RegexMatchTimeoutException exceção. No entanto, uma exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se uma operação correspondente exceder esse intervalo de tempo limite especificado pelomatchTimeout parâmetro .

Notas aos Chamadores

Recomendamos que você defina o matchTimeout parâmetro como um valor apropriado, como dois segundos. Se você desabilitar tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressões regulares oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite apenas nas seguintes condições:

Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.
Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule correspondências, não correspondências e correspondências próximas com eficiência.
Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.

Confira também

Elementos de linguagem de expressão regular

Aplica-se a

Matches(String, String, RegexOptions)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de caracteres de entrada especificada, usando as opções de correspondência 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

A cadeia de caracteres na qual será pesquisada uma correspondência.

pattern: String

O padrão de expressão regular para correspondência.

options: RegexOptions

Uma combinação bit a bit dos valores de enumeração que especifica opções para correspondência.

Retornos

MatchCollection

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

ArgumentException

Ocorreu um erro de análise da expressão regular.

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores de RegexOptions.

Exemplos

O exemplo a seguir chama o Matches(String, String) método para identificar qualquer palavra em uma frase que termina em "es" e, em seguida, chama o Matches(String, String, RegexOptions) método para executar uma comparação que não diferencia maiúsculas de minúsculas do padrão com a cadeia de caracteres de entrada. Como mostra a saída, os dois métodos retornam 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

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`\w+`	Fazer a correspondência a um ou mais caracteres de palavra.
`es`	Corresponde à cadeia de caracteres literal "es".
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Matches(String, String, RegexOptions) método é semelhante ao Match(String, String, RegexOptions) método , exceto que ele retorna informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

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

Os métodos estáticos Matches são equivalentes a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método Matchesde instância .

Devido à avaliação lenta, chamar o Matches(String, String) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se um intervalo de tempo limite for definido pela propriedade "REGEX_DEFAULT_MATCH_TIMEOUT" do domínio do aplicativo atual e uma operação correspondente exceder esse intervalo de tempo limite.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede que o método atinja o tempo limite, será usado. O método estático recomendado para recuperar várias correspondências de padrão é Matches(String, String, RegexOptions, TimeSpan), que permite definir o intervalo de tempo limite.

Confira também

Elementos de linguagem de expressão regular

Aplica-se a

Matches(String, Int32)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Pesquisa a cadeia de caracteres de entrada especificada para todas as ocorrências de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.

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

A cadeia de caracteres na qual será pesquisada uma correspondência.

startat: Int32

A posição do caractere na cadeia de caracteres de entrada na qual a pesquisa será iniciada.

Retornos

MatchCollection

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

ArgumentNullException

input é null.

ArgumentOutOfRangeException

startat é menor que zero ou maior que o tamanho de input.

Exemplos

O exemplo a seguir usa o Match(String) método para localizar a primeira palavra em uma frase que termina em "es" e, em seguida, chama o Matches(String, Int32) método para identificar as palavras adicionais que terminam em "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

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`\w+`	Fazer a correspondência a um ou mais caracteres de palavra.
`es`	Corresponde à cadeia de caracteres literal "es".
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Matches(String, Int32) método é semelhante ao Match(String, Int32) método , exceto que ele retorna informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

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

O padrão de expressão regular para o qual o Matches(String, Int32) método pesquisa é definido pela chamada para um dos construtores de Regex classe. Para obter mais informações sobre os elementos que podem formar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

Para obter mais detalhes sobre startat, consulte a seção Comentários de Match(String, Int32).

Devido à avaliação lenta, chamar o Matches(String, Int32) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se a MatchTimeout propriedade não Regex.InfiniteMatchTimeout for e uma operação correspondente exceder o intervalo de tempo limite.

Confira também

Elementos da linguagem de expressão regular

Aplica-se a

Matches(String)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Pesquisa todas as ocorrências de uma expressão regular na cadeia de caracteres de entrada especificada.

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

A cadeia de caracteres na qual será pesquisada uma correspondência.

Retornos

MatchCollection

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

ArgumentNullException

input é null.

Exemplos

O exemplo a seguir usa o Matches(String) método para identificar qualquer palavra em uma frase que termine em "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

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`\w+`	Fazer a correspondência a um ou mais caracteres de palavra.
`es`	Corresponda à cadeia de caracteres literal "es".
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Matches(String) método é semelhante ao Match(String) método , exceto pelo fato de retornar informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

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

A coleção inclui apenas correspondências e termina na primeira não correspondência.

O padrão de expressão regular para o qual o Matches(String) método pesquisa é definido pela chamada para um dos construtores de Regex classe. Para obter mais informações sobre os elementos que podem formar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

Devido à avaliação lenta, chamar o Matches(String) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se a MatchTimeout propriedade não Regex.InfiniteMatchTimeout for e uma operação correspondente exceder o intervalo de tempo limite.

Confira também

Elementos da linguagem de expressão regular

Aplica-se a

Matches(String, String)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Pesquisa todas as ocorrências de uma expressão regular especificada na cadeia de entrada especificada.

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

A cadeia de caracteres na qual será pesquisada uma correspondência.

pattern: String

O padrão de expressão regular para correspondência.

Retornos

MatchCollection

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

ArgumentException

Ocorreu um erro de análise da expressão regular.

ArgumentNullException

input ou pattern é null.

Exemplos

O exemplo a seguir usa o Matches(String, String) método para identificar qualquer palavra em uma frase que termine em "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

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`\w+`	Fazer a correspondência a um ou mais caracteres de palavra.
`es`	Corresponda à cadeia de caracteres literal "es".
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Matches(String, String) método é semelhante ao Match(String, String) método , exceto pelo fato de retornar informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

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

Os métodos estáticos Matches são equivalentes a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método Matchesde instância .

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado. O método estático recomendado para recuperar várias correspondências de padrão é Matches(String, String, RegexOptions, TimeSpan), que permite especificar o intervalo de tempo limite.

Confira também

Elementos da linguagem de expressão regular

Aplica-se a

Compartilhar via

Regex.Matches Método

Definição

Sobrecargas

Matches(String, String, RegexOptions, TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Matches(String, String, RegexOptions)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Matches(String, Int32)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Matches(String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Matches(String, String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Recursos adicionais