# Match.NextMatch Méthode

## Définition

Retourne un nouvel objet Match avec les résultats de la correspondance suivante, en commençant à la position à laquelle la dernière correspondance s'est terminée (au niveau du caractère qui se trouve après le dernier caractère correspondant).Returns a new Match object with the results for the next match, starting at the position at which the last match ended (at the character after the last matched character).

``````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.The next regular expression match.

#### Exceptions

Un délai d’attente a expiré.A time-out occurred.

## Exemples

L’exemple suivant utilise la méthode NextMatch pour capturer des correspondances d’expressions régulières au-delà de la première correspondance.The following example uses the NextMatch method to capture regular expression matches beyond the first match.

``````#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 de Regex.Match(String, Int32) et au passage de (`Index+Length`) comme nouvelle position de départ.This method is similar to calling Regex.Match(String, Int32) again and passing (`Index+Length`) as the new starting position.

Notes

Cette méthode ne modifie pas l’instance actuelle.This method does not modify the current instance. Au lieu de cela, elle retourne un nouvel objet Match qui contient des informations sur la correspondance suivante.Instead, it returns a new Match object that contains information about the next match.

La tentative de récupération de la correspondance suivante peut lever une RegexMatchTimeoutException si une valeur de délai d’attente pour les opérations de correspondance est activée et si la tentative de recherche de la correspondance suivante dépasse cet intervalle de délai d’attente.Attempting to retrieve the next match may throw a RegexMatchTimeoutException if a time-out value for matching operations is in effect and the attempt to find the next match exceeds that time-out interval.

## Notes pour les appelants

Quand une tentative de correspondance est répétée en appelant la méthode NextMatch(), le moteur d’expression régulière donne aux correspondances vides un traitement spécial.When a match attempt is repeated by calling the NextMatch() method, the regular expression engine gives empty matches special treatment. En règle générale, NextMatch() commence la recherche de la correspondance suivante exactement là où la correspondance précédente s’est arrêtée.Usually, NextMatch() begins the search for the next match exactly where the previous match left off. Toutefois, après une correspondance vide, la méthode NextMatch() avance d’un caractère avant d’essayer la correspondance suivante.However, after an empty match, the NextMatch() method advances by one character before trying the next match. Ce comportement garantit que le moteur des expressions régulières va progresser dans la chaîne.This behavior guarantees that the regular expression engine will progress through the string. Dans le cas contraire, étant donné qu’une correspondance vide n’entraîne pas de déplacement vers l’avant, la correspondance suivante démarre exactement au même emplacement que la correspondance précédente, et elle correspond à la même chaîne vide de façon répétée.Otherwise, because an empty match does not result in any forward movement, the next match would start in exactly the same place as the previous match, and it would match the same empty string repeatedly.

L'exemple suivant illustre cette situation.The following example provides an illustration. Le modèle d’expression régulière `a *` recherche zéro, une ou plusieurs occurrences de la lettre « a » dans la chaîne « abaabb ».The regular expression pattern `a*` searches for zero or more occurrences of the letter "a" in the string "abaabb". Comme le montre la sortie de l’exemple, la recherche trouve six correspondances.As the output from the example shows, the search finds six matches. La première tentative de correspondance trouve le premier « a ».The first match attempt finds the first "a". La deuxième correspondance démarre exactement là où la première correspondance se termine, avant le premier b ; elle recherche zéro occurrences de « a » et retourne une chaîne vide.The second match starts exactly where the first match ends, before the first b; it finds zero occurrences of "a" and returns an empty string. 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.The third match does not begin exactly where the second match ended, because the second match returned an empty string. Au lieu de cela, il commence un caractère plus tard, après le premier « b ».Instead, it begins one character later, after the first "b". La troisième correspondance recherche deux occurrences de « a » et retourne « AA ».The third match finds two occurrences of "a" and returns "aa". La quatrième tentative de correspondance commence là où la troisième correspondance s’est terminée, avant le deuxième « b », et retourne une chaîne vide.The fourth match attempt begins where the third match ended, before the second "b", and returns an empty string. La cinquième tentative de correspondance fait avancer un caractère afin qu’il commence avant le troisième « b » et retourne une chaîne vide.The fifth match attempt again advances one character so that it begins before the third "b" and returns an empty string. La sixième correspondance commence après le dernier « b » et retourne une chaîne vide.The sixth match begins after the last "b" and returns an empty string again.

[ ! code-CSharpSystem. Text. RegularExpressions. match. NextMatch # 1] [ ! code-VBSystem. Text. RegularExpressions. match. NextMatch # 1][!code-csharpSystem.Text.RegularExpressions.Match.NextMatch#1] [!code-vbSystem.Text.RegularExpressions.Match.NextMatch#1]