Regex.Matches Methode

Definition

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

Überlädt

Matches(String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines 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, String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines 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, 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)

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

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 Übereinstimmung mit der Literalzeichenfolge "es".
\b Der Vergleich endet an einer Wortgrenze.

Hinweise

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

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 Sprache für reguläre Ausdrücke – Kurzübersicht.

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

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String) -Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das von dieser Methode zurückgegebene Objekt ausgeführt MatchCollection wird, wenn die MatchTimeout -Eigenschaft nicht ist Regex.InfiniteMatchTimeout und ein übereinstimmender Vorgang das Time out-Intervall überschreitet.

Siehe auch

Gilt für

Matches(String, Int32)

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

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, int startat);
public System.Text.RegularExpressions.MatchCollection Matches (string input, int startat);
member this.Matches : string * int -> System.Text.RegularExpressions.MatchCollection
Public Function Matches (input As String, startat As Integer) As MatchCollection

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

startat
Int32

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

Gibt zurück

MatchCollection

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

Ausnahmen

input ist null.

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 mit "es" endet, und dann die -Methode aufruft, Matches(String, Int32) 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 Übereinstimmung mit der Literalzeichenfolge "es".
\b Der Vergleich endet an einer Wortgrenze.

Hinweise

Die Matches(String, Int32) -Methode ähnelt der Match(String, Int32) -Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen in der Eingabezeichenfolge anstelle einer einzelnen Übereinstimmung zurückgibt. Dies 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 Sprache für reguläre Ausdrücke – Kurzübersicht.

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

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String, Int32) -Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das von dieser Methode zurückgegebene Objekt ausgeführt MatchCollection wird, wenn die MatchTimeout -Eigenschaft nicht ist Regex.InfiniteMatchTimeout und ein übereinstimmender Vorgang das Time out-Intervall überschreitet.

Siehe auch

Gilt für

Matches(String, String)

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

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern);
static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String) As MatchCollection

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

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

Gibt zurück

MatchCollection

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

Ausnahmen

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

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 Übereinstimmung mit der Literalzeichenfolge "es".
\b Der Vergleich endet an einer Wortgrenze.

Hinweise

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

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. 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.

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

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String, String) -Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das von dieser Methode zurückgegebene Objekt ausgeführt MatchCollection wird, wenn ein Time out-Intervall von der "REGEX_DEFAULT_MATCH_TIMEOUT"-Eigenschaft der aktuellen Anwendungsdomäne definiert wird und ein übereinstimmender Vorgang dieses Time out-Intervall überschreitet.

Hinweise für Aufrufer

Diese Methode führt nach einem Intervall, das dem Standardtime out-Wert der Anwendungsdomäne, in der sie aufgerufen wird, zu einem Time out-Wert kommt. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Timeout aufgetreten ist. Die empfohlene statische Methode zum Abrufen mehrerer Musterabstände ist Matches(String, String, RegexOptions, TimeSpan) , mit der Sie das Time out-Intervall angeben können.

Siehe auch

Gilt für

Matches(String, String, RegexOptions)

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

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String, options As RegexOptions) As MatchCollection

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

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

options
RegexOptions

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

Gibt zurück

MatchCollection

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

Ausnahmen

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

input oder pattern ist null.

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

Beispiele

Das folgende Beispiel ruft die Matches(String, String) -Methode auf, um jedes 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 mit der Eingabezeichenfolge ohne Beachtung der Groß-/Kleinschreibung 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 Übereinstimmung mit der Literalzeichenfolge "es".
\b Der Vergleich endet an einer Wortgrenze.

Hinweise

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

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. 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.

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

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches(String, String) -Methode keine RegexMatchTimeoutException Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das von dieser Methode zurückgegebene Objekt ausgeführt MatchCollection wird, wenn ein Time out-Intervall von der "REGEX_DEFAULT_MATCH_TIMEOUT"-Eigenschaft der aktuellen Anwendungsdomäne definiert wird und ein übereinstimmender Vorgang dieses Time out-Intervall überschreitet.

Hinweise für Aufrufer

Diese Methode führt nach einem Intervall, das dem Standardtime out-Wert der Anwendungsdomäne, in der sie aufgerufen wird, zu einem Time out-Wert kommt. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Timeout aufgetreten ist. Die empfohlene statische Methode zum Abrufen mehrerer Musterabstände ist Matches(String, String, RegexOptions, TimeSpan) , mit der Sie das Time out-Intervall festlegen können.

Siehe auch

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.

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

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

input oder pattern ist null.

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 -Methode zum Ausführen eines Vergleichs mit Sensitiver Schreibung mit jedem Wort in einem Satz, der auf "es" endet, Matches(String, String, RegexOptions, TimeSpan) aufruft. Anschließend ruft sie die -Methode auf, um einen Vergleich des Musters mit der Eingabezeichenfolge ohne Unterscheidung nach Matches(String, String, RegexOptions, TimeSpan) Groß-/Kleinschreibung durchzuführen. In beiden Fällen wird das Time out-Intervall 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 Übereinstimmung mit der Literalzeichenfolge "es".
\b Der Vergleich endet an einer Wortgrenze.

Hinweise

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

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

            match = match.NextMatch();
      }  
   }
   catch (RegexMatchTimeoutException) {
      // Do nothing: assume that exception represents no match.
   }
   Try
      Dim match As Match = Regex.Match(input, pattern, options, 
                                       TimeSpan.FromSeconds(1))
      Do While match.Success
            ' Handle match here...

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

Die statischen Methoden entsprechen dem Erstellen eines -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Matches Regex Aufrufen der Instanzmethode 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 Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzreferenz.

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

Aufgrund der verzögerten Auswertung löst der Aufruf der Matches -Methode keine Ausnahme RegexMatchTimeoutException aus. Eine Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn ein übereinstimmende Vorgang dieses vom -Parameter angegebene Time MatchCollection out-Intervall matchTimeout überschreitet.

Hinweise für Aufrufer

Es wird empfohlen, den Parameter matchTimeout auf einen entsprechenden Wert (z. B. zwei Sekunden) zu setzen. Wenn Sie Time outs deaktivieren, indem Sie angeben, bietet InfiniteMatchTimeout die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Sie sollten Time outs 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 übereinstimmende und nahezu übereinstimmende Übereinstimmungen effizient verarbeitet werden.

– Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bei der Verarbeitung einer Nahezu-Übereinstimmung bekannterweise eine übermäßige Rückverfolgung verursachen.

Siehe auch

Gilt für