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)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

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 mit einem beliebigen Wort in einem Satz übereinstimmt, der mit "es" endet. Anschließend wird die Matches(String, String, RegexOptions, TimeSpan) -Methode aufgerufen, um einen Vergleich des Musters ohne Berücksichtigung der Groß-/Kleinschreibung mit der Eingabezeichenfolge durchzufü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 -Methode, mit der Match(String, String, RegexOptions, TimeSpan) Ausnahme, dass sie Anstelle einer einzelnen Übereinstimmung Informationen zu allen Übereinstimmungen in der Eingabezeichenfolge zurückgibt. 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 Matches Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Aufrufen der instance-Methode Matches.

Der pattern Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Kurzreferenz.

Die Matches -Methode verwendet die verzögerte Auswertung, um das zurückgegebene Objekt aufzufüllen MatchCollection . Durch den Zugriff auf Elemente dieser Auflistung wie MatchCollection.Count und MatchCollection.CopyTo wird die Auflistung sofort aufgefüllt. Um die vorteile der verzögerten Auswertung zu nutzen, sollten Sie die Auflistung mithilfe eines Konstrukts wie foreach in C# und For Each...Next in Visual Basic durchlaufen.

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches -Methode keine Ausnahme aus RegexMatchTimeoutException . 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 das durch denmatchTimeout Parameter angegebene Timeoutintervall überschreitet.

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 die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Sie sollten Timeouts jedoch nur unter den folgenden Bedingungen deaktivieren:

Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass Übereinstimmungen, Nicht-Übereinstimmungen und Fast-Übereinstimmungen effizient verarbeitet werden.
Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, von denen bekannt ist, dass sie bei der Verarbeitung einer nahen Übereinstimmung eine übermäßige Rückverfolgung verursachen.

Weitere Informationen

Sprachelemente für reguläre Ausdrücke

Gilt für:

Matches(String, String, RegexOptions)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

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 beliebiges Wort in einem Satz zu identifizieren, der mit "es" endet, und ruft dann die Matches(String, String, RegexOptions) -Methode auf, um einen Vergleich des Musters ohne Berücksichtigung der Groß-/Kleinschreibung mit der Eingabezeichenfolge durchzufü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 -Methode, mit der Match(String, String, RegexOptions) Ausnahme, dass sie Anstelle einer einzelnen Übereinstimmung Informationen zu allen Übereinstimmungen in der Eingabezeichenfolge zurückgibt. 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 Matches Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Aufrufen der instance-Methode Matches.

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String, String) -Methode keine Ausnahme aus RegexMatchTimeoutException . 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 Abgleichsvorgang dieses Timeoutintervall überschreitet.

Hinweise für Aufrufer

Bei dieser Methode tritt ein Timeout nach einem Intervall auf, das dem Standardtimeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der ein Timeout der Methode verhindert. Die empfohlene statische Methode zum Abrufen mehrerer Musterübersprechungen ist Matches(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

Sprachelemente für reguläre Ausdrücke

Gilt für:

Matches(String, Int32)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

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 Match(String) -Methode verwendet, um das erste Wort in einem Satz zu finden, der auf "es" endet, und ruft dann die Matches(String, Int32) -Methode auf, um alle zusätzlichen Wörter zu identifizieren, die auf "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`	Stimmen Sie mit der Literalzeichenfolge "es" überein.
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, Int32) -Methode ähnelt der -Methode, mit der Match(String, Int32) Ausnahme, dass sie Anstelle einer einzelnen Übereinstimmung Informationen zu allen Übereinstimmungen in der Eingabezeichenfolge zurückgibt. 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 Muster für reguläre Ausdrücke, nach dem die Matches(String, Int32) Methode sucht, wird durch den Aufruf eines der Regex Klassenkonstruktoren definiert. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Regular Expression Language – Schnellreferenz.

Weitere Informationen zu startatfinden Sie im Abschnitt Hinweise von Match(String, Int32).

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String, Int32) -Methode keine Ausnahme aus RegexMatchTimeoutException . 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 Regex.InfiniteMatchTimeout ist und ein abgleichendes Vorgang das Timeoutintervall überschreitet.

Weitere Informationen

Sprachelemente für reguläre Ausdrücke

Gilt für:

Matches(String)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

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 alle Wörter in einem Satz zu identifizieren, die auf "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?";
      
      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`	Stimmen Sie mit der Literalzeichenfolge "es" überein.
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String) -Methode ähnelt der -Methode, mit der Match(String) Ausnahme, dass sie Anstelle einer einzelnen Übereinstimmung Informationen zu allen Übereinstimmungen in der Eingabezeichenfolge zurückgibt. 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 endet bei der ersten Nicht-Übereinstimmung.

Das Muster für reguläre Ausdrücke, nach dem die Matches(String) Methode sucht, wird durch den Aufruf eines der Regex Klassenkonstruktoren definiert. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Regular Expression Language – Schnellreferenz.

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String) -Methode keine Ausnahme aus RegexMatchTimeoutException . 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 Regex.InfiniteMatchTimeout ist und ein abgleichendes Vorgang das Timeoutintervall überschreitet.

Weitere Informationen

Sprachelemente für reguläre Ausdrücke

Gilt für:

Matches(String, String)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

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 jedes Wort in einem Satz zu identifizieren, der mit "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`	Stimmen Sie mit der Literalzeichenfolge "es" überein.
`\b`	Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, String) -Methode ähnelt der -Methode, mit der Match(String, String) Ausnahme, dass sie Anstelle einer einzelnen Übereinstimmung Informationen zu allen Übereinstimmungen in der Eingabezeichenfolge zurückgibt. 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 Muster für reguläre Ausdrücke und dem Aufrufen der instance-Methode Matches.

Hinweise für Aufrufer

Weitere Informationen

Sprachelemente für reguläre Ausdrücke

Gilt für:

Freigeben über

Regex.Matches Methode

Definition

Überlädt

Matches(String, String, RegexOptions, TimeSpan)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Matches(String, String, RegexOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Matches(String, Int32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Matches(String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Matches(String, String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen