Match.NextMatch Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Restituisce un nuovo oggetto Match con i risultati relativi alla corrispondenza successiva, partendo dalla posizione in cui terminava l'ultima corrispondenza (dal carattere dopo l'ultimo carattere corrispondente).
public:
System::Text::RegularExpressions::Match ^ NextMatch();public System.Text.RegularExpressions.Match NextMatch ();member this.NextMatch : unit -> System.Text.RegularExpressions.MatchPublic Function NextMatch () As MatchRestituisce
Corrispondenza dell'espressione regolare successiva.
Eccezioni
Si è verificato un timeout.
Esempio
Nell'esempio seguente viene usato il NextMatch metodo per acquisire corrispondenze regolari oltre la prima corrispondenza.
#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
Commenti
Questo metodo è simile alla chiamata Regex.Match(String, Int32) di nuovo e al passaggio (Index+Length) come nuova posizione iniziale.
Nota
Questo metodo non modifica l'istanza corrente. Restituisce invece un nuovo Match oggetto che contiene informazioni sulla corrispondenza successiva.
Il tentativo di recuperare la corrispondenza successiva può generare un'eccezione RegexMatchTimeoutException se è attivo un valore di timeout per le operazioni di corrispondenza e il tentativo di trovare la corrispondenza successiva supera tale intervallo di timeout.
Note per i chiamanti
Quando un tentativo di corrispondenza viene ripetuto chiamando il NextMatch() metodo , il motore delle espressioni regolari fornisce corrispondenze vuote per un trattamento speciale. In genere, NextMatch() inizia la ricerca della corrispondenza successiva esattamente dove è stata interrotta la corrispondenza precedente. Tuttavia, dopo una corrispondenza vuota, il NextMatch() metodo avanza di un carattere prima di provare la corrispondenza successiva. Questo comportamento garantisce che il motore delle espressioni regolari passi attraverso la stringa. In caso contrario, poiché una corrispondenza vuota non comporta alcun movimento in avanti, la corrispondenza successiva inizierebbe esattamente nella stessa posizione della corrispondenza precedente e corrisponderebbe ripetutamente alla stessa stringa vuota.
Nell'esempio seguente viene illustrato questo concetto. Il criterio a* di espressione regolare cerca zero o più occorrenze della lettera "a" nella stringa "abaabb". Come illustrato nell'output dell'esempio, la ricerca trova sei corrispondenze. Il primo tentativo di corrispondenza trova il primo "a". La seconda corrispondenza inizia esattamente dove termina la prima corrispondenza, prima del primo b; trova zero occorrenze di "a" e restituisce una stringa vuota. La terza corrispondenza non inizia esattamente dove è terminata la seconda corrispondenza, perché la seconda corrispondenza ha restituito una stringa vuota. Inizia invece un carattere in un secondo momento, dopo il primo "b". La terza corrispondenza trova due occorrenze di "a" e restituisce "aa". Il quarto tentativo di corrispondenza inizia dove è terminata la terza corrispondenza, prima del secondo "b" e restituisce una stringa vuota. Il quinto tentativo di corrispondenza avanza di nuovo un carattere in modo che inizi prima del terzo "b" e restituisca una stringa vuota. La sesta corrispondenza inizia dopo l'ultima "b" e restituisce di nuovo una stringa vuota.
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.
