Match.NextMatch Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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).
public:
System::Text::RegularExpressions::Match ^ NextMatch();public System.Text.RegularExpressions.Match NextMatch ();member this.NextMatch : unit -> System.Text.RegularExpressions.MatchPublic Function NextMatch () As MatchRetours
Correspondance d'expression régulière suivante.
Exceptions
Un délai d’attente a expiré.
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.
Notes
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.
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 »:::