Regex.Matches Methode

Referenz

Definition

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Durchsucht eine Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks und gibt alle Übereinstimmungen zurück.

Überlädt

Matches(String, String, RegexOptions, TimeSpan)	Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls nach allen Vorkommen des angegebenen regulären Ausdrucks.
Matches(String, String, RegexOptions)	Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach allen Vorkommen des angegebenen regulären Ausdrucks.
Matches(String, Int32)	Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.
Matches(String)	Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks.
Matches(String, String)	Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines angegebenen regulären Ausdrucks.

Matches(String, String, RegexOptions, TimeSpan)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls nach allen Vorkommen des angegebenen regulären Ausdrucks.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Matches : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.MatchCollection

Public Shared Function Matches (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As MatchCollection

Parameter

input: String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern: String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

matchTimeout: TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

input oder pattern ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

- oder - matchTimeout ist negativ, null oder größer als ca. 24 Tage.

Beispiele

Im folgenden Beispiel wird die Matches(String, String, RegexOptions, TimeSpan) Methode aufgerufen, um einen Vergleich zwischen Groß- und Kleinschreibung durchzuführen, der einem Wort in einem Satz entspricht, der in "es" endet. Anschließend wird die Matches(String, String, RegexOptions, TimeSpan) Methode aufgerufen, um einen Vergleich zwischen Groß- und Kleinschreibung des Musters mit der Eingabezeichenfolge auszuführen. In beiden Fällen wird das Timeoutintervall auf eine Sekunde festgelegt. Wie die Ausgabe zeigt, geben die beiden Methoden unterschiedliche Ergebnisse zurück.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      try {
         foreach (Match match in Regex.Matches(sentence, pattern,
                                               RegexOptions.None,
                                               TimeSpan.FromSeconds(1)))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {
         // Do Nothing: Assume that timeout represents no match.
      }
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      try { 
         foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {}
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern, 
                                               RegexOptions.None, 
                                               TimeSpan.FromSeconds(1))
         Try
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Catch e As RegexMatchTimeoutException
            ' Do Nothing: Assume that timeout represents no match.
         End Try
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      Try
         For Each match As Match In Regex.Matches(sentence, pattern, 
                                                  RegexOptions.IgnoreCase,
                                                  TimeSpan.FromSeconds(1))
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Next
      Catch de As RegexMatchTimeoutException
         ' Do Nothing: Assume that timeout represents no match.
      End Try
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

Das Muster für reguläre Ausdrücke \b\w+es\b wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibung
`\b`	Der Vergleich beginnt an einer Wortgrenze.
`\w+`	Übereinstimmung mit mindestens einem Wortzeichen.
`es`	Stimmen Sie mit der Literalzeichenfolge "es" überein.
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, String, RegexOptions, TimeSpan) Methode ähnelt der Match(String, String, RegexOptions, TimeSpan) Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Eingabezeichenfolge gefunden wurden, anstelle einer einzelnen Übereinstimmung. Es entspricht dem folgenden Code:

   try {
      Match match = Regex.Match(input, pattern, options,
                                TimeSpan.FromSeconds(1));
      while (match.Success) {
            // Handle match here...

            match = match.NextMatch();
      }  
   }
   catch (RegexMatchTimeoutException) {
      // Do nothing: assume that exception represents no match.
   }

   Try
      Dim match As Match = Regex.Match(input, pattern, options, 
                                       TimeSpan.FromSeconds(1))
      Do While match.Success
            ' Handle match here...

            match = match.NextMatch()
      Loop  
   Catch e As RegexMatchTimeoutException
      ' Do nothing: assume that exception represents no match.
   End Try

Die statischen Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Matches Ausdrucksmuster und aufrufen der InstanzmethodeMatches.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Kurzübersicht.

Die Matches Methode verwendet eine lazy-Auswertung, um das zurückgegebene Objekt aufzufüllen MatchCollection . Der Zugriff auf Elemente dieser Auflistung, z MatchCollection.Count . B. und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt wird. Um die Auswertung zu nutzen, sollten Sie die Sammlung mithilfe eines Konstrukts wie foreach in C# und For Each...Next in Visual Basic iterieren.

Aufgrund der lazy-Auswertung löst das Aufrufen der Matches Methode keine RegexMatchTimeoutException Ausnahme aus. Eine Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn ein übereinstimmendes Vorgang dieses timeout-Intervalls überschreitet, dasmatchTimeout vom Parameter angegeben wird.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet das reguläre Ausdrucksmodul etwas bessere Leistung. Sie sollten Timeouts jedoch nur unter den folgenden Bedingungen deaktivieren:

Wenn die von einem regulären Ausdruck verarbeitete Eingabe aus einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dadurch werden Text ausgeschlossen, der von Benutzern dynamisch eingegeben wurde.
Wenn das reguläre Ausdrucksmuster gründlich getestet wurde, um sicherzustellen, dass übereinstimmungen, nicht übereinstimmende und nahe Übereinstimmungen effizient verarbeitet werden.
Wenn das Reguläre Ausdrucksmuster keine Sprachelemente enthält, die bekannt sind, dass beim Verarbeiten einer Nahübereinstimmung eine übermäßige Rückverfolgung verursacht wird.

Siehe auch

Sprachelemente für reguläre Ausdrücke

Gilt für

Matches(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach allen Vorkommen des angegebenen regulären Ausdrucks.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection

Public Shared Function Matches (input As String, pattern As String, options As RegexOptions) As MatchCollection

Parameter

input: String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern: String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

input oder pattern ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

Beispiele

Im folgenden Beispiel wird die Matches(String, String) Methode aufgerufen, um ein Wort in einem Satz zu identifizieren, der in "es" endet, und ruft dann die Matches(String, String, RegexOptions) Methode auf, um einen Vergleich zwischen Groß- und Kleinschreibung des Musters mit der Eingabezeichenfolge auszuführen. Wie die Ausgabe zeigt, geben die beiden Methoden unterschiedliche Ergebnisse zurück.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      For Each match As Match In Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

Das Muster für reguläre Ausdrücke \b\w+es\b wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibung
`\b`	Der Vergleich beginnt an einer Wortgrenze.
`\w+`	Übereinstimmung mit mindestens einem Wortzeichen.
`es`	Stimmen Sie mit der Literalzeichenfolge "es" überein.
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, String, RegexOptions) Methode ähnelt der Match(String, String, RegexOptions) Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Eingabezeichenfolge gefunden wurden, anstelle einer einzelnen Übereinstimmung. Es entspricht dem folgenden Code:

Match match = Regex.Match(input, pattern, options);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = Regex.Match(input, pattern, options)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Die statischen Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Matches Ausdrucksmuster und aufrufen der InstanzmethodeMatches.

Aufgrund der lazy-Auswertung löst das Aufrufen der Matches(String, String) Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn ein Timeoutintervall durch die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" der aktuellen Anwendungsdomäne definiert wird und ein abgleicher Vorgang dieses Timeoutintervalls überschreitet.

Hinweise für Aufrufer

Diese Methode timeouts nach einem Intervall, das dem Standardmäßigen Timeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der die Methode verhindert, dass die Zeitüberschreitung erfolgt. Die empfohlene statische Methode zum Abrufen mehrerer Mustervergleiche ist Matches(String, String, RegexOptions, TimeSpan), wodurch Sie das Timeoutintervall festlegen können.

Siehe auch

Sprachelemente für reguläre Ausdrücke

Gilt für

Matches(String, Int32)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, int startat);

public System.Text.RegularExpressions.MatchCollection Matches (string input, int startat);

member this.Matches : string * int -> System.Text.RegularExpressions.MatchCollection

Public Function Matches (input As String, startat As Integer) As MatchCollection

Parameter

input: String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

startat: Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen werden soll.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

ArgumentNullException

input ist null.

ArgumentOutOfRangeException

startat ist kleiner als 0 (null) oder größer als die Länge von input.

Beispiele

Im folgenden Beispiel wird die Methode verwendet, um das erste Wort in einem Satz zu finden, der in "es" endet, und ruft dann die Match(String) Matches(String, Int32) Methode auf, um zusätzliche Wörter zu identifizieren, die in "es" enden.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes and uses our paper?";
      
      // Get the first match.
      Match match = rgx.Match(sentence);
      if (match.Success) {
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", 
                           match.Value, match.Index);
         // Get any additional matches.
         foreach (Match m in rgx.Matches(sentence, match.Index + match.Length))
            Console.WriteLine("Also found '{0}' at position {1}", 
                              m.Value, m.Index);
      }   
   }
}
// The example displays the following output:
//       Found first 'es' in 'writes' at position 4
//       Also found 'notes' at position 17
//       Also found 'uses' at position 27

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes and uses our paper?"
      
      ' Get the first match.
      Dim match As Match = rgx.Match(sentence)
      If match.Success Then
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", _
                           match.Value, match.Index)
         ' Get any additional matches.
         For Each match In rgx.Matches(sentence, match.Index + match.Length)
            Console.WriteLine("Also found '{0}' at position {1}", _
                              match.Value, match.Index)
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Found first 'es' in 'writes' at position 4
'       Also found 'notes' at position 17
'       Also found 'uses' at position 27

Das Muster für reguläre Ausdrücke \b\w+es\b wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibung
`\b`	Der Vergleich beginnt an einer Wortgrenze.
`\w+`	Übereinstimmung mit mindestens einem Wortzeichen.
`es`	Entspricht der Literalzeichenfolge "es".
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, Int32) Methode ähnelt der Methode, außer dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Match(String, Int32) Eingabezeichenfolge gefunden wurden, anstatt eine einzelne Übereinstimmung. Es entspricht dem folgenden Code:

Match match = regex.Match(input, startAt);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = regex.Match(input, startAt)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Das reguläre Ausdrucksmuster, für das die Matches(String, Int32) Methode durchsucht wird, wird durch den Aufruf eines der Regex Klassenkonstruktoren definiert. Weitere Informationen zu den Elementen, die ein reguläres Ausdrucksmuster bilden können, finden Sie unter "Reguläre Ausdruckssprache - Kurzübersicht".

Weitere Informationen finden startatSie im Abschnitt "Hinweise" von Match(String, Int32).

Die Matches Methode verwendet die lazy-Auswertung, um das zurückgegebene Objekt aufzufüllen MatchCollection . Der Zugriff auf Elemente dieser Auflistung, z MatchCollection.Count . B. und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort gefüllt wird. Um die Lazy-Bewertung zu nutzen, sollten Sie die Sammlung mithilfe eines Konstrukts wie foreach in C# und For Each...Next in Visual Basic iterieren.

Aufgrund seiner lazy-Bewertung löst das Aufrufen der Matches(String, Int32) Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang auf dem MatchCollection von dieser Methode zurückgegebenen Objekt ausgeführt wird, wenn die MatchTimeout Eigenschaft nicht Regex.InfiniteMatchTimeout ist und ein übereinstimmendes Vorgang das Timeoutintervall überschreitet.

Siehe auch

Sprachelemente für reguläre Ausdrücke

Gilt für

Matches(String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks.

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input);

public System.Text.RegularExpressions.MatchCollection Matches (string input);

member this.Matches : string -> System.Text.RegularExpressions.MatchCollection

Public Function Matches (input As String) As MatchCollection

Parameter

input: String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

ArgumentNullException

input ist null.

Beispiele

Im folgenden Beispiel wird die Matches(String) Methode verwendet, um Wörter in einem Satz zu identifizieren, der in "es" endet.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes?";
      
      foreach (Match match in rgx.Matches(sentence))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes?"
      
      For Each match As Match In rgx.Matches(sentence)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

Das Muster für reguläre Ausdrücke \b\w+es\b wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibung
`\b`	Der Vergleich beginnt an einer Wortgrenze.
`\w+`	Übereinstimmung mit mindestens einem Wortzeichen.
`es`	Entspricht der Literalzeichenfolge "es".
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String) Methode ähnelt der Methode, außer dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Match(String) Eingabezeichenfolge gefunden wurden, anstatt eine einzelne Übereinstimmung. Es entspricht dem folgenden Code:

Match match = regex.Match(input);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = regex.Match(input)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Die Auflistung enthält nur Übereinstimmungen und beendet sie bei der ersten nicht übereinstimmenden Übereinstimmung.

Das reguläre Ausdrucksmuster, für das die Matches(String) Methode durchsucht wird, wird durch den Aufruf eines der Regex Klassenkonstruktoren definiert. Weitere Informationen zu den Elementen, die ein reguläres Ausdrucksmuster bilden können, finden Sie unter "Reguläre Ausdruckssprache - Kurzübersicht".

Aufgrund seiner lazy-Bewertung löst das Aufrufen der Matches(String) Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang auf dem MatchCollection von dieser Methode zurückgegebenen Objekt ausgeführt wird, wenn die MatchTimeout Eigenschaft nicht Regex.InfiniteMatchTimeout ist und ein übereinstimmendes Vorgang das Timeoutintervall überschreitet.

Siehe auch

Sprachelemente für reguläre Ausdrücke

Gilt für

Matches(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines angegebenen regulären Ausdrucks.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern);

static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection

Public Shared Function Matches (input As String, pattern As String) As MatchCollection

Parameter

input: String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern: String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

input oder pattern ist null.

Beispiele

Im folgenden Beispiel wird die Matches(String, String) Methode verwendet, um ein Wort in einem Satz zu identifizieren, der in "es" endet.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "Who writes these notes?";
      
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "Who writes these notes?"
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

Das Muster für reguläre Ausdrücke \b\w+es\b wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibung
`\b`	Der Vergleich beginnt an einer Wortgrenze.
`\w+`	Übereinstimmung mit mindestens einem Wortzeichen.
`es`	Entspricht der Literalzeichenfolge "es".
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, String) Methode ähnelt der Methode, außer dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Match(String, String) Eingabezeichenfolge gefunden wurden, anstatt eine einzelne Übereinstimmung. Es entspricht dem folgenden Code:

Match match = Regex.Match(input, pattern);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Die statischen Matches Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Ausdrucksmuster und aufrufen der Instanzmethode Matches.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die Zeichenfolge symbolisch beschreiben, die übereinstimmen. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Quick Reference.

Aufgrund seiner lazy-Bewertung löst das Aufrufen der Matches(String, String) Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang auf dem von dieser Methode zurückgegebenen Objekt ausgeführt wird, wenn ein Timeoutintervall durch die MatchCollection Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" der aktuellen Anwendungsdomäne definiert wird und ein übereinstimmendes Vorgang dieses Timeoutintervalls überschreitet.

Hinweise für Aufrufer

Siehe auch

Sprachelemente für reguläre Ausdrücke

Gilt für

Regex.Matches Methode

Definition

Überlädt

Matches(String, String, RegexOptions, TimeSpan)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

Matches(String, String, RegexOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

Matches(String, Int32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Siehe auch

Gilt für

Matches(String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Siehe auch

Gilt für

Matches(String, String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

Zusätzliche Ressourcen