Regex.Matches Regex.Matches Regex.Matches Regex.Matches Method

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) Matches(String) Matches(String) 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) Matches(String, Int32) Matches(String, Int32) 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) Matches(String, String) Matches(String, 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) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) 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) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) 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) Matches(String) Matches(String) 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 String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

Gibt zurück

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

Beispiele

Im folgenden Beispiel wird die Matches(String) Methode, um alle Wörter in einem Satz zu identifizieren, die auf "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 Beschreibung Description
\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 literalen Zeichenfolge "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 dem Unterschied, dass die It Informationen über alle Übereinstimmungen zurückgibt, finden Sie in der Eingabezeichenfolge, anstelle einer einzelnen Übereinstimmung sucht.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.

Muster für reguläre Ausdrücke für die die Matches(String) Methode durchsucht wird durch den Aufruf eines definiert die Regex Klassenkonstruktoren.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 Sprachelemente 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 mithilfe der verzögerten Auswertung, füllen Sie das zurückgegebene MatchCollection Objekt.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Zugriff auf Mitglieder dieser Sammlung wie z. B. MatchCollection.Count und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt werden.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um verzögerte Auswertung nutzen zu können, sollten Sie die Auflistung durchlaufen, mit einem Konstrukt wie foreach in C# geschrieben und For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext in Visual Basic.in Visual Basic.

Aufgrund der verzögerten Auswertung Aufrufen der Matches(String) Methode löst keine RegexMatchTimeoutException Ausnahme.Because of its lazy evaluation, calling the Matches(String) method does not throw a RegexMatchTimeoutException exception. Jedoch die Ausnahme wird ausgelöst, wenn ein Vorgang ausgeführt wird, auf die MatchCollection Objekt, das von dieser Methode zurückgegeben wird, wenn die MatchTimeout Eigenschaft ist nicht Regex.InfiniteMatchTimeout und ein Abgleichsvorgang überschreitet das Timeoutintervall.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.

Siehe auch

Matches(String, Int32) Matches(String, Int32) Matches(String, Int32) 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 String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

startat
Int32 Int32 Int32 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

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

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, um das erste Wort im Satz zu ermitteln, die in "es" endet, und ruft dann die Matches(String, Int32) Methode, um alle weiteren Wörter zu identifizieren, die auf "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 Beschreibung Description
\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 literalen Zeichenfolge "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 dem Unterschied, dass die It Informationen über alle Übereinstimmungen zurückgibt, finden Sie in der Eingabezeichenfolge, anstelle einer einzelnen Übereinstimmung sucht.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  

Muster für reguläre Ausdrücke für die die Matches(String, Int32) Methode durchsucht wird durch den Aufruf eines definiert die Regex Klassenkonstruktoren.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 Sprachelemente 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 mithilfe der verzögerten Auswertung, füllen Sie das zurückgegebene MatchCollection Objekt.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Zugriff auf Mitglieder dieser Sammlung wie z. B. MatchCollection.Count und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt werden.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um verzögerte Auswertung nutzen zu können, sollten Sie die Auflistung durchlaufen, mit einem Konstrukt wie foreach in C# geschrieben und For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext in Visual Basic.in Visual Basic.

Aufgrund der verzögerten Auswertung Aufrufen der Matches(String, Int32) Methode löst keine RegexMatchTimeoutException Ausnahme.Because of its lazy evaluation, calling the Matches(String, Int32) method does not throw a RegexMatchTimeoutException exception. Allerdings wird die Ausnahme ausgelöst, wenn ein Vorgang ausgeführt wird, auf die MatchCollection Objekt, das von dieser Methode zurückgegeben wird, wenn die MatchTimeout Eigenschaft ist nicht Regex.InfiniteMatchTimeout und ein Abgleichsvorgang überschreitet das Timeoutintervall..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..

Siehe auch

Matches(String, String) Matches(String, String) Matches(String, 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.

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 String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

pattern
String String String String

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

Gibt zurück

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, um alle Wörter in einem Satz zu identifizieren, die mit "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 Beschreibung Description
\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 literalen Zeichenfolge "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 dem Unterschied, dass die It Informationen über alle Übereinstimmungen zurückgibt, finden Sie in der Eingabezeichenfolge, anstelle einer einzelnen Übereinstimmung sucht.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 statische Matches Methoden sind gleichwertig mit der Erstellung einer Regex Objekt mit dem angegebenen regulären Ausdrucksmuster und 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.

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge 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 reguläre Ausdrücke von .NET Framework und Sprachelemente 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 mithilfe der verzögerten Auswertung, füllen Sie das zurückgegebene MatchCollection Objekt.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Zugriff auf Mitglieder dieser Sammlung wie z. B. MatchCollection.Count und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt werden.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um verzögerte Auswertung nutzen zu können, sollten Sie die Auflistung durchlaufen, mit einem Konstrukt wie foreach in C# geschrieben und For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext in Visual Basic.in Visual Basic.

Aufgrund der verzögerten Auswertung Aufrufen der Matches(String, String) Methode löst keine RegexMatchTimeoutException Ausnahme.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 ausgeführt wird, auf die MatchCollection Objekt, das von dieser Methode zurückgegeben wird, wenn ein Timeoutintervall, durch die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" von der aktuellen Anwendungsdomäne und einen Abgleichsvorgang definiert ist überschreitet das Timeoutintervall an.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

Diese-Methode ein Timeout, nach einem bestimmten Zeitintervall, das gleich der Standardwert für das Timeout der Anwendungsdomäne, in dem sie aufgerufen wird. 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 Sie ein Timeoutwert für die Anwendungsdomäne, der Wert nicht definiert wurde InfiniteMatchTimeout, das Timeout, die Methode verhindert werden. 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. Statische Methode wird nicht für mehrere Muster abrufen entspricht Matches(String, String, RegexOptions, TimeSpan), sodass Sie das Timeoutintervall angeben. The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you specify the time-out interval.

Siehe auch

Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) 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 String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

pattern
String String String String

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

options
RegexOptions RegexOptions RegexOptions 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

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, um alle Wörter im Satz zu identifizieren, die auf "es" endet, und ruft dann die Matches(String, String, RegexOptions) Methode zum Ausführen eines Vergleichs Groß-/Kleinschreibung des Musters mit der Eingabezeichenfolge.The 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. Die Ausgabe zeigt, werden 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 Beschreibung Description
\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 literalen Zeichenfolge "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 dem Unterschied, dass die It Informationen über alle Übereinstimmungen zurückgibt, finden Sie in der Eingabezeichenfolge, anstelle einer einzelnen Übereinstimmung sucht.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 statische Matches Methoden sind gleichwertig mit der Erstellung einer Regex Objekt mit dem angegebenen regulären Ausdrucksmuster und 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.

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge 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 reguläre Ausdrücke von .NET Framework und Sprachelemente 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 mithilfe der verzögerten Auswertung, füllen Sie das zurückgegebene MatchCollection Objekt.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Zugriff auf Mitglieder dieser Sammlung wie z. B. MatchCollection.Count und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt werden.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um verzögerte Auswertung nutzen zu können, sollten Sie die Auflistung durchlaufen, mit einem Konstrukt wie foreach in C# geschrieben und For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext in Visual Basic.in Visual Basic.

Aufgrund der verzögerten Auswertung Aufrufen der Matches(String, String) Methode löst keine RegexMatchTimeoutException Ausnahme.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 ausgeführt wird, auf die MatchCollection Objekt, das von dieser Methode zurückgegeben wird, wenn ein Timeoutintervall, durch die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" von der aktuellen Anwendungsdomäne und einen Abgleichsvorgang definiert ist überschreitet das Timeoutintervall an.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

Diese-Methode ein Timeout, nach einem bestimmten Zeitintervall, das gleich der Standardwert für das Timeout der Anwendungsdomäne, in dem sie aufgerufen wird. 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 Sie ein Timeoutwert für die Anwendungsdomäne, der Wert nicht definiert wurde InfiniteMatchTimeout, das Timeout, die Methode verhindert werden. 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. Statische Methode wird nicht für mehrere Muster abrufen entspricht Matches(String, String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen. The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Siehe auch

Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) 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 String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

pattern
String String String String

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

options
RegexOptions RegexOptions RegexOptions 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 TimeSpan TimeSpan 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

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, um einen Vergleich Groß-/Kleinschreibung auszuführen, die alle Wörter in einem Satz entspricht, die mit "es" endet.The 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". Es ruft dann die Matches(String, String, RegexOptions, TimeSpan) Methode zum Ausführen eines Vergleichs Groß-/Kleinschreibung des Musters mit der Eingabezeichenfolge.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 Timeoutintervall auf eine Sekunde festgelegt.In both cases, the time-out interval is set to one second. Die Ausgabe zeigt, werden 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 Beschreibung Description
\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 literalen Zeichenfolge "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 dem Unterschied, dass die It Informationen über alle Übereinstimmungen zurückgibt, finden Sie in der Eingabezeichenfolge, anstelle einer einzelnen Übereinstimmung sucht.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 statische Matches Methoden sind gleichwertig mit der Erstellung einer Regex Objekt mit dem angegebenen regulären Ausdrucksmuster und 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.

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge 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 reguläre Ausdrücke von .NET Framework und Sprachelemente 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 mithilfe der verzögerten Auswertung, füllen Sie das zurückgegebene MatchCollection Objekt.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Zugriff auf Mitglieder dieser Sammlung wie z. B. MatchCollection.Count und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt werden.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Um verzögerte Auswertung nutzen zu können, sollten Sie die Auflistung durchlaufen, mit einem Konstrukt wie foreach in C# geschrieben und For Each...NextTo take advantage of lazy evaluation, you should iterate the collection by using a construct such as foreach in C# and For EachNext in Visual Basic.in Visual Basic.

Aufgrund der verzögerten Auswertung Aufrufen der Matches Methode löst keine RegexMatchTimeoutException Ausnahme.Because of its lazy evaluation, calling the Matches method does not throw a RegexMatchTimeoutException exception. Allerdings wird eine Ausnahme ausgelöst, wenn ein Vorgang ausgeführt wird, auf die MatchCollection Objekt, das von dieser Methode zurückgegeben wird, übersteigt ein Abgleichsvorgang mit diesem Timeoutintervall, die gemäß dermatchTimeout Parameter.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, Sie legen die matchTimeout Parameter auf einen geeigneten Wert, z. B. zwei Sekunden. We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts werden, indem deaktiviert InfiniteMatchTimeout, die Engine für reguläre Ausdrücke bietet eine etwas bessere Leistung. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Allerdings sollten Sie Timeouts nur unter folgenden Bedingungen deaktivieren: However, you should disable time-outs only under the following conditions: – Wenn die Eingabe verarbeitet, die von einem regulären Ausdruck aus einer bekannten und vertrauenswürdigen Quelle stammt oder besteht aus statischen Text. - 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, der vom Benutzer eingegebene dynamisch wurde. This excludes text that has been dynamically input by users. – Wenn Sie Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass er effizient verarbeitet übereinstimmt, nicht-Übereinstimmungen und Naher entspricht. - When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches. – Wenn Muster für reguläre Ausdrücke keine Language-Elemente enthält, die bekannt sind, um eine übermäßige rückverfolgung bei der Verarbeitung einer Nahen Übereinstimmung zu verursachen. - When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Siehe auch

Gilt für: