Regex.Matches Methode

Definition

Durchsucht eine Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks und gibt alle Übereinstimmungen zurück.Searches an input string for all occurrences of a regular expression and returns all the matches.

Überlädt

Matches(String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines angegebenen regulären Ausdrucks.Searches the specified input string for all occurrences of a specified regular expression.

Matches(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach allen Vorkommen des angegebenen regulären Ausdrucks.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

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.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

Matches(String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks.Searches the specified input string for all occurrences of a regular expression.

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.The string to search for a match.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte.A collection of the Match objects found by the search. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.If no matches are found, the method returns an empty collection object.

Ausnahmen

input ist null.input is null.

Beispiele

Im folgenden Beispiel wird die- Matches(String) Methode verwendet, um Wörter in einem Satz zu identifizieren, die mit "es" enden.The following example uses the Matches(String) method to identify any words in a sentence that end in "es".

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:The regular expression pattern \b\w+es\b is defined as shown in the following table.

MusterPattern BeschreibungDescription
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
es Entspricht der Literalzeichenfolge "es".Match the literal string "es".
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Hinweise

Die- Matches(String) Methode ähnelt der- Match(String) Methode, mit der Ausnahme, dass Sie Informationen zu allen in der Eingabe Zeichenfolge gefundenen Übereinstimmungen anstelle einer einzelnen Übereinstimmung zurückgibt.The Matches(String) method is similar to the Match(String) method, except that it returns information about all the matches found in the input string, instead of a single match. Dies entspricht dem folgenden Code:It is equivalent to the following 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 endet bei der ersten nicht Übereinstimmung.The collection includes only matches and terminates at the first non-match.

Das Muster für reguläre Ausdrücke, für das die- Matches(String) Methode sucht, wird durch den-Befehl eines der Regex Klassenkonstruktoren definiert.The regular expression pattern for which the Matches(String) method searches is defined by the call to one of the Regex class constructors. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Die- Matches Methode verwendet die verzögerte Auswertung, um das zurückgegebene-Objekt aufzufüllen MatchCollection .The Matches method uses lazy evaluation to populate the returned MatchCollection object. Der Zugriff auf Member dieser Auflistung MatchCollection.Count , z MatchCollection.CopyTo . b. und, bewirkt, dass die Auflistung sofort aufgefüllt wird.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um die verzögerte Auswertung zu nutzen, sollten Sie die Auflistung mit einem Konstrukt wie foreach in c# und For Each ... in Visual Basic durchlaufen Next .To take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For Each...Next in Visual Basic.

Aufgrund der verzögerten Auswertung löst der Aufruf der- Matches(String) Methode keine- RegexMatchTimeoutException Ausnahme aus.Because of its lazy evaluation, calling the Matches(String) method does not throw a RegexMatchTimeoutException exception. Die-Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene-Objekt ausgeführt wird, wenn die MatchTimeout -Eigenschaft nicht ist Regex.InfiniteMatchTimeout und ein Abgleichsvorgang das Timeout Intervall überschreitet.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if the MatchTimeout property is not Regex.InfiniteMatchTimeout and a matching operation exceeds the time-out interval.

Gilt für:

Matches(String, Int32)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

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.The string to search for a match.

startat
Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen werden soll.The character position in the input string at which to start the search.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte.A collection of the Match objects found by the search. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.If no matches are found, the method returns an empty collection object.

Ausnahmen

input ist null.input is null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.startat is less than zero or greater than the length of input.

Beispiele

Im folgenden Beispiel wird die Match(String) -Methode verwendet, um das erste Wort in einem Satz zu suchen, der mit "es" endet, und dann die-Methode aufruft, Matches(String, Int32) um alle zusätzlichen Wörter zu identifizieren, die mit "es" enden.The following example uses the Match(String) method to find the first word in a sentence that ends in "es", and then calls the Matches(String, Int32) method to identify any additional words that end in "es".

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:The regular expression pattern \b\w+es\b is defined as shown in the following table.

MusterPattern BeschreibungDescription
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
es Entspricht der Literalzeichenfolge "es".Match the literal string "es".
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Hinweise

Die- Matches(String, Int32) Methode ähnelt der- Match(String, Int32) Methode, mit der Ausnahme, dass Sie Informationen zu allen in der Eingabe Zeichenfolge gefundenen Übereinstimmungen anstelle einer einzelnen Übereinstimmung zurückgibt.The Matches(String, Int32) method is similar to the Match(String, Int32) method, except that it returns information about all the matches found in the input string, instead of a single match. Dies entspricht dem folgenden Code:It is equivalent to the following 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 Muster für reguläre Ausdrücke, für das die- Matches(String, Int32) Methode sucht, wird durch den-Befehl eines der Regex Klassenkonstruktoren definiert.The regular expression pattern for which the Matches(String, Int32) method searches is defined by the call to one of the Regex class constructors. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Die- Matches Methode verwendet die verzögerte Auswertung, um das zurückgegebene-Objekt aufzufüllen MatchCollection .The Matches method uses lazy evaluation to populate the returned MatchCollection object. Der Zugriff auf Member dieser Auflistung MatchCollection.Count , z MatchCollection.CopyTo . b. und, bewirkt, dass die Auflistung sofort aufgefüllt wird.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um die verzögerte Auswertung zu nutzen, sollten Sie die Auflistung mit einem Konstrukt wie foreach in c# und For Each ... in Visual Basic durchlaufen Next .To take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For Each...Next in Visual Basic.

Aufgrund der verzögerten Auswertung löst der Aufruf der- Matches(String, Int32) Methode keine- RegexMatchTimeoutException Ausnahme aus.Because of its lazy evaluation, calling the Matches(String, Int32) method does not throw a RegexMatchTimeoutException exception. Die-Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene-Objekt ausgeführt wird, wenn die MatchTimeout -Eigenschaft nicht ist Regex.InfiniteMatchTimeout und ein Abgleichsvorgang das Timeout Intervall überschreitet.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if the MatchTimeout property is not Regex.InfiniteMatchTimeout and a matching operation exceeds the time-out interval.

Gilt für:

Matches(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines angegebenen regulären Ausdrucks.Searches the specified input string for all occurrences of a specified regular expression.

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.The string to search for a match.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte.A collection of the Match objects found by the search. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.If no matches are found, the method returns an empty collection object.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input oder pattern ist null.input or pattern is null.

Beispiele

Im folgenden Beispiel wird die- Matches(String, String) Methode verwendet, um ein beliebiges Wort in einem Satz zu identifizieren, der auf "es" endet.The following example uses the Matches(String, String) method to identify any word in a sentence that ends in "es".

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:The regular expression pattern \b\w+es\b is defined as shown in the following table.

MusterPattern BeschreibungDescription
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
es Entspricht der Literalzeichenfolge "es".Match the literal string "es".
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Hinweise

Die- Matches(String, String) Methode ähnelt der- Match(String, String) Methode, mit der Ausnahme, dass Sie Informationen zu allen in der Eingabe Zeichenfolge gefundenen Übereinstimmungen anstelle einer einzelnen Übereinstimmung zurückgibt.The Matches(String, String) method is similar to the Match(String, String) method, except that it returns information about all the matches found in the input string, instead of a single match. Dies entspricht dem folgenden Code:It is equivalent to the following 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 Muster für reguläre Ausdrücke und dem Aufrufen der Instanzmethode Matches .The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

Der- pattern Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Die- Matches Methode verwendet die verzögerte Auswertung, um das zurückgegebene-Objekt aufzufüllen MatchCollection .The Matches method uses lazy evaluation to populate the returned MatchCollection object. Der Zugriff auf Member dieser Auflistung MatchCollection.Count , z MatchCollection.CopyTo . b. und, bewirkt, dass die Auflistung sofort aufgefüllt wird.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um die verzögerte Auswertung zu nutzen, sollten Sie die Auflistung mit einem Konstrukt wie foreach in c# und For Each ... in Visual Basic durchlaufen Next .To take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For Each...Next in Visual Basic.

Aufgrund der verzögerten Auswertung löst der Aufruf der- Matches(String, String) Methode keine- RegexMatchTimeoutException Ausnahme aus.Because of its lazy evaluation, calling the Matches(String, String) method does not throw a RegexMatchTimeoutException exception. Allerdings wird die Ausnahme ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn ein Timeout Intervall durch die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" der aktuellen Anwendungsdomäne definiert wird und ein Abgleichsvorgang dieses Timeout Intervall überschreitet.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if a time-out interval is defined by the "REGEX_DEFAULT_MATCH_TIMEOUT" property of the current application domain and a matching operation exceeds this time-out interval.

Hinweise für Aufrufer

Bei dieser Methode wird nach einem Intervall, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der Sie aufgerufen wird, ein Timeout festgestellt.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeout verwendet, der das Timeout der Methode verhindert.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Abrufen mehrerer Muster Übereinstimmungen ist, mit der Matches(String, String, RegexOptions, TimeSpan) Sie das Timeout Intervall angeben können.The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you specify the time-out interval.

Gilt für:

Matches(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach allen Vorkommen des angegebenen regulären Ausdrucks.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

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.The string to search for a match.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that specify options for matching.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte.A collection of the Match objects found by the search. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.If no matches are found, the method returns an empty collection object.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input oder pattern ist null.input or pattern is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.options is not a valid bitwise combination of RegexOptions values.

Beispiele

Im folgenden Beispiel wird die Matches(String, String) -Methode aufgerufen, um ein beliebiges Wort in einem Satz zu identifizieren, der mit "es" endet, und dann die Matches(String, String, RegexOptions) -Methode aufruft, um einen Vergleich des Musters mit der Eingabe Zeichenfolge ohne Beachtung der Groß-und kleinThe following example calls the Matches(String, String) method to identify any word in a sentence that ends in "es", and then calls the Matches(String, String, RegexOptions) method to perform a case-insensitive comparison of the pattern with the input string. Wie die Ausgabe zeigt, geben die beiden Methoden unterschiedliche Ergebnisse zurück.As the output shows, the two methods return different results.

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:The regular expression pattern \b\w+es\b is defined as shown in the following table.

MusterPattern BeschreibungDescription
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
es Entspricht der Literalzeichenfolge "es".Match the literal string "es".
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Hinweise

Die- Matches(String, String, RegexOptions) Methode ähnelt der- Match(String, String, RegexOptions) Methode, mit der Ausnahme, dass Sie Informationen zu allen in der Eingabe Zeichenfolge gefundenen Übereinstimmungen anstelle einer einzelnen Übereinstimmung zurückgibt.The Matches(String, String, RegexOptions) method is similar to the Match(String, String, RegexOptions) method, except that it returns information about all the matches found in the input string, instead of a single match. Dies entspricht dem folgenden Code:It is equivalent to the following 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 Matches Methoden entsprechen dem Erstellen eines Regex -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Aufrufen der Instanzmethode Matches .The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

Der- pattern Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Die- Matches Methode verwendet die verzögerte Auswertung, um das zurückgegebene-Objekt aufzufüllen MatchCollection .The Matches method uses lazy evaluation to populate the returned MatchCollection object. Der Zugriff auf Member dieser Auflistung MatchCollection.Count , z MatchCollection.CopyTo . b. und, bewirkt, dass die Auflistung sofort aufgefüllt wird.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um die verzögerte Auswertung zu nutzen, sollten Sie die Auflistung mit einem Konstrukt wie foreach in c# und For Each ... in Visual Basic durchlaufen Next .To take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For Each...Next in Visual Basic.

Aufgrund der verzögerten Auswertung löst der Aufruf der- Matches(String, String) Methode keine- RegexMatchTimeoutException Ausnahme aus.Because of its lazy evaluation, calling the Matches(String, String) method does not throw a RegexMatchTimeoutException exception. Allerdings wird die Ausnahme ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn ein Timeout Intervall durch die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" der aktuellen Anwendungsdomäne definiert wird und ein Abgleichsvorgang dieses Timeout Intervall überschreitet.However, the exception is thrown when an operation is performed on the MatchCollection object returned by this method, if a time-out interval is defined by the "REGEX_DEFAULT_MATCH_TIMEOUT" property of the current application domain and a matching operation exceeds this time-out interval.

Hinweise für Aufrufer

Bei dieser Methode wird nach einem Intervall, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der Sie aufgerufen wird, ein Timeout festgestellt.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeout verwendet, der das Timeout der Methode verhindert.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Abrufen mehrerer Muster Übereinstimmungen ist, mit der Matches(String, String, RegexOptions, TimeSpan) Sie das Timeout Intervall festlegen können.The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Gilt für:

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.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

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.The string to search for a match.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that specify options for matching.

matchTimeout
TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Gibt zurück

MatchCollection

Eine Auflistung der im Suchvorgang gefundenen Match-Objekte.A collection of the Match objects found by the search. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.If no matches are found, the method returns an empty collection object.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input oder pattern ist null.input or pattern is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.options is not a valid bitwise combination of RegexOptions values.

- oder --or- matchTimeout ist negativ, null oder größer als ca. 24 Tage.matchTimeout is negative, zero, or greater than approximately 24 days.

Beispiele

Im folgenden Beispiel wird die Matches(String, String, RegexOptions, TimeSpan) -Methode aufgerufen, um einen Vergleich mit Berücksichtigung der Groß-/Kleinschreibung durchzuführen, der mit einem beliebigen Wort in einem Satz übereinstimmt, der mitThe following example calls the Matches(String, String, RegexOptions, TimeSpan) method to perform a case-sensitive comparison that matches any word in a sentence that ends in "es". Anschließend wird die Matches(String, String, RegexOptions, TimeSpan) -Methode aufgerufen, um einen Vergleich des Musters mit der Eingabe Zeichenfolge ohne Beachtung der Groß-und Kleinschreibung auszuführen.It then calls the Matches(String, String, RegexOptions, TimeSpan) method to perform a case-insensitive comparison of the pattern with the input string. In beiden Fällen wird das Timeout Intervall auf eine Sekunde festgelegt.In both cases, the time-out interval is set to one second. Wie die Ausgabe zeigt, geben die beiden Methoden unterschiedliche Ergebnisse zurück.As the output shows, the two methods return different results.

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:The regular expression pattern \b\w+es\b is defined as shown in the following table.

MusterPattern BeschreibungDescription
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
es Entspricht der Literalzeichenfolge "es".Match the literal string "es".
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Hinweise

Die- Matches(String, String, RegexOptions, TimeSpan) Methode ähnelt der- Match(String, String, RegexOptions, TimeSpan) Methode, mit der Ausnahme, dass Sie Informationen zu allen in der Eingabe Zeichenfolge gefundenen Übereinstimmungen anstelle einer einzelnen Übereinstimmung zurückgibt.The Matches(String, String, RegexOptions, TimeSpan) method is similar to the Match(String, String, RegexOptions, TimeSpan) method, except that it returns information about all the matches found in the input string, instead of a single match. Dies entspricht dem folgenden Code:It is equivalent to the following 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 Matches Methoden entsprechen dem Erstellen eines Regex -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Aufrufen der Instanzmethode Matches .The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

Der- pattern Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Die- Matches Methode verwendet die verzögerte Auswertung, um das zurückgegebene-Objekt aufzufüllen MatchCollection .The Matches method uses lazy evaluation to populate the returned MatchCollection object. Der Zugriff auf Member dieser Auflistung MatchCollection.Count , z MatchCollection.CopyTo . b. und, bewirkt, dass die Auflistung sofort aufgefüllt wird.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um die verzögerte Auswertung zu nutzen, sollten Sie die Auflistung mit einem Konstrukt wie foreach in c# und For Each ... in Visual Basic durchlaufen Next .To take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For Each...Next in Visual Basic.

Aufgrund der verzögerten Auswertung löst der Aufruf der- Matches Methode keine- RegexMatchTimeoutException Ausnahme aus.Because of its lazy evaluation, calling the Matches method does not throw a RegexMatchTimeoutException exception. Eine-Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene-Objekt ausgeführt wird, wenn eine übereinstimmende Operation dieses Timeout Intervall überschreitet, das durch den-Parameter angegeben wird matchTimeout .However, an exception is thrown when an operation is performed on the MatchCollection object returned by this method, if a matching operation exceeds this time-out interval specified by thematchTimeout parameter.

Hinweise für Aufrufer

Es wird empfohlen, den- matchTimeout Parameter auf einen geeigneten Wert, z. b. zwei Sekunden, festzulegen.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts durch Angeben von deaktivieren InfiniteMatchTimeout , bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Timeouts sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden:However, you should disable time-outs only under the following conditions: : Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet ist oder aus statischem Text besteht.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.This excludes text that has been dynamically input by users.

: Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, nicht-Übereinstimmungen und NEAR-Übereinstimmungen effizient behandelt.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine nahe Übereinstimmung verarbeitet wird.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Gilt für: