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

Match

Correspondance d'expression régulière suivante.

Exceptions

Exemples

L’exemple suivant utilise la NextMatch méthode pour capturer les correspondances d’expression régulière au-delà de la première correspondance.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

using System;
using System.Text.RegularExpressions;

class Example
{
   static void Main()
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);

      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success)
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++)
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++)
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Remarques

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

Toute 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 de correspondance est en vigueur et que la tentative de recherche de la correspondance suivante dépasse cet intervalle de délai d’attente.

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 aux 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. Dans le cas contraire, étant donné qu’une correspondance vide n’entraîne aucun mouvement vers l’avant, la correspondance suivante commence 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 d’expression régulière a* recherche zéro occurrence ou plus de la lettre « a » dans la chaîne « abaabb ». Comme le montre la sortie de l’exemple, la recherche trouve six correspondances. La première tentative de correspondance trouve le premier « a ». La deuxième correspondance commence exactement à l’endroit où se termine la première correspondance, avant le premier b; il trouve zéro occurrence de « a » et retourne une chaîne vide. La troisième correspondance ne commence pas exactement à l’endroit 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 la deuxième « b », et retourne une chaîne vide. La cinquième correspondance avance à nouveau un caractère pour 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.

::code language="csharp » source="~/snippets/csharp/System.Text.RegularExpressions/Match/NextMatch/nextmatch1.cs » interactive="try-dotnet » id="Snippet1 »:::: :::code language="vb » source="~/snippets/visualbasic/VS_Snippets_CLR_System/system.text.regularexpressions.match.nextmatch/vb/nextmatch1.vb » id="Snippet1 »:::

S’applique à