Match.NextMatch Metod

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

Returer

Nästa reguljära uttryck matchar.

Undantag

Kommentarer

Den här metoden liknar anropet Match(String, Int32) igen och skickas Index + Length som den nya startpositionen.

Den här metoden ändrar inte den aktuella instansen. I stället returneras ett nytt Match objekt som innehåller information om nästa matchning.

Om du försöker hämta nästa matchning kan det utlösa ett RegexMatchTimeoutException timeout-värde för matchande åtgärder och försöket att hitta nästa matchning överskrider tidsgränsen.

När du försöker matcha ett mönster för reguljära uttryck mot en tom matchning kommer motorn för reguljära uttryck att föra fram ett tecken i indatasträngen innan matchningen görs igen för att undvika en oändlig loop. Anropare bör inte anta att varje matchning kommer att avancera med minst en position, eftersom matchningar med noll bredd är möjliga.

Anteckningar till anropare

När ett matchningsförsök upprepas genom att anropa NextMatch() metoden ger reguljära uttrycksmotorn tomma matchningar specialbehandling. NextMatch() Vanligtvis börjar sökningen efter nästa match exakt där den föregående matchen slutade. Men efter en tom matchning NextMatch() avancerar metoden med ett tecken innan nästa matchning provas. Det här beteendet garanterar att motorn för reguljära uttryck fortsätter genom strängen. Annars, eftersom en tom matchning inte resulterar i någon framåtrörelse, startar nästa match på exakt samma plats som föregående matchning, och den skulle matcha samma tomma sträng upprepade gånger.

I följande exempel visas en bild. Mönster för reguljära uttryck a* söker efter noll eller fler förekomster av bokstaven "a" i strängen "abaabb". Som utdata från exemplet visar hittar sökningen sex matchningar. Det första matchningsförsöket hittar det första "a". Den andra matchningen börjar exakt där den första matchen slutar, före den första b; den hittar noll förekomster av "a" och returnerar en tom sträng. Den tredje matchen börjar inte exakt där den andra matchen slutade, eftersom den andra matchen returnerade en tom sträng. I stället börjar ett tecken senare, efter det första "b". Den tredje matchningen hittar två förekomster av "a" och returnerar "aa". Det fjärde matchförsöket börjar där den tredje matchen slutade, före den andra "b", och returnerar en tom sträng. Det femte matchningsförsöket avancerar återigen ett tecken så att det börjar före det tredje "b" och returnerar en tom sträng. Den sjätte matchen börjar efter det sista "b" och returnerar en tom sträng igen.

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.