Match.NextMatch Metodo

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

Valori restituiti

Corrispondenza dell'espressione regolare successiva.

Eccezioni

Commenti

Questo metodo è simile alla chiamata Match(String, Int32) di nuovo e al Index + Length passaggio come nuova posizione iniziale.

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.

Quando si tenta di trovare una corrispondenza con un criterio di espressione regolare rispetto a una corrispondenza vuota, il motore delle espressioni regolari farà avanzare un carattere nella stringa di input prima di ritentare la corrispondenza, per evitare un ciclo infinito. I chiamanti non devono presupporre che ogni corrispondenza avanza di almeno una posizione, perché sono possibili corrispondenze di larghezza zero.

Note per i chiamanti

Quando un tentativo di corrispondenza viene ripetuto chiamando il NextMatch() metodo , il motore delle espressioni regolari fornisce una corrispondenza vuota corrisponde a 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 progredisca 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.

Di seguito ne viene illustrato un esempio. 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. Al contrario, inizia 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 fa avanzare 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.