Match.NextMatch Método

public:
 System::Text::RegularExpressions::Match ^ NextMatch();

public System.Text.RegularExpressions.Match NextMatch();

member this.NextMatch : unit -> System.Text.RegularExpressions.Match

Public Function NextMatch () As Match

Retornos

A próxima correspondência de expressão regular.

Exceções

Comentários

Esse método é semelhante a chamar Match(String, Int32) novamente e passar Index + Length como a nova posição inicial.

Esse método não modifica a instância atual. Em vez disso, ele retorna um novo Match objeto que contém informações sobre a próxima correspondência.

A tentativa de recuperar a próxima correspondência pode gerar um RegexMatchTimeoutException valor de tempo limite para operações correspondentes estiver em vigor e a tentativa de localizar a próxima correspondência exceder esse intervalo de tempo limite.

Ao tentar corresponder um padrão de expressão regular a uma correspondência vazia, o mecanismo de expressão regular avançará um caractere na cadeia de caracteres de entrada antes de tentar novamente a correspondência, para evitar um loop infinito. Os chamadores não devem assumir que cada correspondência avançará em pelo menos uma posição, já que correspondências de largura zero são possíveis.

Notas aos Chamadores

Quando uma tentativa de correspondência é repetida chamando o NextMatch() método, o mecanismo de expressão regular fornece correspondências vazias de tratamento especial. Normalmente, NextMatch() inicia a pesquisa para a próxima correspondência exatamente onde a correspondência anterior parou. No entanto, após uma correspondência vazia, o NextMatch() método avança por um caractere antes de tentar a próxima correspondência. Esse comportamento garante que o mecanismo de expressão regular progrida por meio da cadeia de caracteres. Caso contrário, como uma correspondência vazia não resulta em nenhum movimento de avanço, a próxima correspondência seria iniciada exatamente no mesmo lugar da correspondência anterior e corresponderia à mesma cadeia de caracteres vazia repetidamente.

O exemplo a seguir ilustra esse cenário. O padrão a* de expressão regular procura zero ou mais ocorrências da letra "a" na cadeia de caracteres "abaabb". Como mostra a saída do exemplo, a pesquisa localiza seis correspondências. A primeira tentativa de correspondência localiza o primeiro "a". A segunda partida começa exatamente onde a primeira partida termina, antes do primeiro b; ele não encontra nenhuma ocorrência de "a" e retorna uma cadeia de caracteres vazia. A terceira correspondência não começa exatamente onde a segunda partida terminou, porque a segunda correspondência retornou uma cadeia de caracteres vazia. Em vez disso, ele começa um caractere mais tarde, após o primeiro "b". A terceira correspondência localiza duas ocorrências de "a" e retorna "aa". A quarta tentativa de correspondência começa onde a terceira partida terminou, antes do segundo "b", e retorna uma cadeia de caracteres vazia. A quinta tentativa de correspondência avança novamente um caractere para que ele comece antes do terceiro "b" e retorne uma cadeia de caracteres vazia. A sexta partida começa após o último "b" e retorna uma cadeia de caracteres vazia novamente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "a*";
      string input = "abaabb";
      
      Match m = Regex.Match(input, pattern);
      while (m.Success) {
         Console.WriteLine("'{0}' found at index {1}.", 
                           m.Value, m.Index);
         m = m.NextMatch();
      }
   }
}
// The example displays the following output:
//       'a' found at index 0.
//       '' found at index 1.
//       'aa' found at index 2.
//       '' found at index 4.
//       '' found at index 5.
//       '' found at index 6.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "a*"
      Dim input As String = "abaabb"
      
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success
         Console.WriteLine("'{0}' found at index {1}.", 
                           m.Value, m.Index)
         m = m.NextMatch()
      Loop         
   End Sub
End Module
' The example displays the following output:
'       'a' found at index 0.
'       '' found at index 1.
'       'aa' found at index 2.
'       '' found at index 4.
'       '' found at index 5.
'       '' found at index 6.