Match.NextMatch Méthode

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

Retours

Correspondance d’expression régulière suivante.

Exceptions

Remarques

Cette méthode est similaire à l’appel Match(String, Int32) et au passage Index + Length en tant que nouvelle position de départ.

Cette méthode ne modifie pas l’instance actuelle. Au lieu de cela, il retourne un nouvel Match objet qui contient des informations sur la correspondance suivante.

La tentative de récupération de la correspondance suivante peut lever une RegexMatchTimeoutException valeur si une valeur de délai d’attente pour les opérations correspondantes est en vigueur et que la tentative de recherche de la correspondance suivante dépasse cet intervalle de délai d’attente.

Lorsque vous tentez de faire correspondre un modèle d’expression régulière à une correspondance vide, le moteur d’expression régulière avance un caractère dans la chaîne d’entrée avant de réessayer la correspondance pour éviter une boucle infinie. Les appelants ne doivent pas supposer que chaque correspondance avance d’au moins une position, car les correspondances de largeur zéro sont possibles.

Notes pour les appelants

Lorsqu’une tentative de correspondance est répétée en appelant la NextMatch() méthode, le moteur d’expression régulière donne un traitement spécial des correspondances vides. En règle générale, NextMatch() commence la recherche de la correspondance suivante exactement où la correspondance précédente s’est arrêtée. Toutefois, après une correspondance vide, la NextMatch() méthode avance d’un caractère avant d’essayer la correspondance suivante. Ce comportement garantit que le moteur d’expression régulière progresse dans la chaîne. Sinon, étant donné qu’une correspondance vide n’entraîne aucun mouvement vers l’avant, la correspondance suivante démarre exactement au même endroit que la correspondance précédente, et elle correspond à la même chaîne vide à plusieurs reprises.

L'exemple suivant illustre cette situation. Le modèle a* d’expression régulière recherche zéro ou plusieurs occurrences de la lettre « a » dans la chaîne « abaabb ». Comme le montre la sortie de l’exemple, la recherche recherche six correspondances. La première tentative de correspondance recherche le premier « a ». La deuxième correspondance commence exactement à l’endroit où se termine la première correspondance, avant le premier b ; elle trouve zéro occurrences de « a » et retourne une chaîne vide. La troisième correspondance ne commence pas exactement où la deuxième correspondance s’est terminée, car la deuxième correspondance a retourné une chaîne vide. Au lieu de cela, il commence un caractère plus tard, après le premier « b ». La troisième correspondance recherche deux occurrences de « a » et retourne « aa ». La quatrième tentative de correspondance commence à l’endroit où la troisième correspondance s’est terminée, avant le deuxième « b », et retourne une chaîne vide. La cinquième tentative de correspondance avance à nouveau un caractère afin qu’il commence avant le troisième « b » et retourne une chaîne vide. La sixième correspondance commence après le dernier « b » et retourne à nouveau une chaîne vide.

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.