Regex.Matches Methode

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

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

Gibt zurück

Eine Auflistung der Objekte, die Match von der Suche gefunden wurden. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

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 Wort in einem Satz übereinstimmt, der auf "es" endet. Anschließend wird die Matches(String, String, RegexOptions, TimeSpan) Methode aufgerufen, um einen Vergleich zwischen Groß- und Kleinschreibung des Musters mit der Eingabezeichenfolge 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 \b\w+es\b für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

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

Hinweise

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

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

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

Aufgrund ihrer faulen Auswertung löst RegexMatchTimeoutException das Aufrufen der Matches Methode keine Ausnahme aus. Eine Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn ein Abgleichsvorgang dieses 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 durch Angeben InfiniteMatchTimeoutdeaktivieren, bietet das Modul für reguläre Ausdrücke 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. Dadurch wird Text ausgeschlossen, der dynamisch von Benutzern eingegeben wurde.

• Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und nahe Übereinstimmungen effizient verarbeitet.

• Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen zu übermäßigem Rückverfolgungsverhalten bei der Verarbeitung einer Nahübereinstimmung führen.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

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

Gibt zurück

Eine Auflistung der Objekte, die Match von der Suche gefunden wurden. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

Beispiele

Im folgenden Beispiel wird die Matches(String, String) Methode aufgerufen, um ein beliebiges Wort in einem Satz zu identifizieren, der in "es" endet, und ruft dann die Matches(String, String, RegexOptions) Methode auf, um einen Vergleich zwischen Groß- und Kleinschreibung des Musters mit der Eingabezeichenfolge 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 \b\w+es\b für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

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

Hinweise

Die Matches(String, String, RegexOptions) Methode ähnelt der Match(String, String, RegexOptions) Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Eingabezeichenfolge gefunden wurden, anstelle einer einzigen Übereinstimmung. Sie 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 mit regulären Ausdrücken, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Kurzübersicht.

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

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

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, 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 die Zeitüberschreitung der Methode verhindert. Die empfohlene statische Methode zum Abrufen mehrerer Mustervergleiche ist Matches(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

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

Gibt zurück

Eine Auflistung der Objekte, die Match von der Suche gefunden wurden. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

Beispiele

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Das Muster \b\w+es\b für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Schema	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 Match(String, Int32) Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Eingabezeichenfolge gefunden wurden, anstelle einer einzigen Übereinstimmung. Sie 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 durchsucht wird, 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.

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

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

Aufgrund ihrer faulen Auswertung löst RegexMatchTimeoutException das Aufrufen der Matches(String, Int32) Methode keine Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn die MatchTimeout Eigenschaft nicht Regex.InfiniteMatchTimeout ist und ein abgleicher Vorgang das Timeoutintervall überschreitet.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

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

Gibt zurück

Eine Auflistung der Objekte, die Match von der Suche gefunden wurden. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

Beispiele

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Das Muster \b\w+es\b für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Schema	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 Match(String) Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Eingabezeichenfolge gefunden wurden, anstelle einer einzigen Übereinstimmung. Sie entspricht dem folgenden Code:

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

      match = match.NextMatch();
}

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

      match = match.NextMatch()
Loop

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

Das Muster für reguläre Ausdrücke, nach dem die Matches(String) Methode durchsucht wird, 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 eine faule Auswertung, um das zurückgegebene MatchCollection Objekt aufzufüllen. Der Zugriff auf Elemente dieser Auflistung, MatchCollection.Count z. B. und MatchCollection.CopyTo bewirkt, dass die Auflistung sofort aufgefüllt wird. Um die Vorteile der faulen Auswertung zu nutzen, sollten Sie die Sammlung mithilfe eines Konstrukts wie foreach in C# und For Each...Next in Visual Basic durchlaufen.

Aufgrund ihrer faulen Auswertung löst RegexMatchTimeoutException das Aufrufen der Matches(String) Methode keine Ausnahme aus. Die Ausnahme wird jedoch ausgelöst, wenn ein Vorgang für das MatchCollection von dieser Methode zurückgegebene Objekt ausgeführt wird, wenn die MatchTimeout Eigenschaft nicht Regex.InfiniteMatchTimeout ist und ein abgleicher Vorgang das Timeoutintervall überschreitet.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

Quelle:

Regex.Match.cs

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

Gibt zurück

Eine Auflistung der Objekte, die Match von der Suche gefunden wurden. Wenn keine Übereinstimmungen gefunden werden, gibt die Methode ein leeres Auflistungsobjekt zurück.

Ausnahmen

Beispiele

Im folgenden Beispiel wird die Matches(String, String) Methode verwendet, um ein beliebiges Wort in einem Satz zu identifizieren, der auf "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 \b\w+es\b für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Schema	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 Match(String, String) Methode, mit der Ausnahme, dass sie Informationen zu allen Übereinstimmungen zurückgibt, die in der Eingabezeichenfolge gefunden wurden, anstelle einer einzigen Übereinstimmung. Sie 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 mit regulären Ausdrücken, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Kurzübersicht.

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

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

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, 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 die Zeitüberschreitung der Methode verhindert. Die empfohlene statische Methode zum Abrufen mehrerer Mustervergleiche ist Matches(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall angeben können.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke