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

Definicja

Wyszukuje ciąg wejściowy dla wszystkich wystąpień elementu wyrażenia regularnego i zwraca wszystkie dopasowania.Searches an input string for all occurrences of a regular expression and returns all the matches.

Przeciążenia

Matches(String) Matches(String) Matches(String) Matches(String)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia wyrażeń regularnych.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32) Matches(String, Int32) Matches(String, Int32) Matches(String, Int32)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia wyrażeń regularnych, zaczynając od określonej pozycji początkowej w ciągu.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)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego.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)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego, przy użyciu określonych opcji dopasowania.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)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego, przy użyciu określonego dopasowania interwał opcje i limitu czasu.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)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia wyrażeń regularnych.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

Parametry

input
String String String String

Ciąg do wyszukania pod kątem dopasowania.The string to search for a match.

Zwraca

Kolekcja Match obiekty znalezione przez wyszukiwanie.A collection of the Match objects found by the search. Jeśli nie znaleziono żadnych dopasowań, metoda zwraca obiekt pustą kolekcję.If no matches are found, the method returns an empty collection object.

Wyjątki

Przykłady

W poniższym przykładzie użyto Matches(String) metodę identyfikowania wyrazów w zdaniu, które kończą się na "es".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

Definicję wzorca wyrażenia regularnego \b\w+es\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b\w+es\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
es Jest zgodny z ciągiem literału "es".Match the literal string "es".
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Uwagi

Matches(String) Metoda jest podobna do Match(String) znaleziono metody, z wyjątkiem, że zwraca informacje na temat wszystkie dopasowania w ciągu wejściowym, a nie pojedyncze dopasowanie.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. Odpowiada to następującemu kodowi: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  

Kolekcja zawiera tylko zgodności i kończy się na pierwszym bez dopasowania.The collection includes only matches and terminates at the first non-match.

Wzorzec wyrażenia regularnego, dla którego Matches(String) metoda wyszukiwania jest definiowany przez wywołanie jednej z Regex klasy konstruktorów.The regular expression pattern for which the Matches(String) method searches is defined by the call to one of the Regex class constructors. Aby uzyskać więcej informacji na temat elementy tworzące wzorzec wyrażenia regularnego, zobacz język wyrażeń regularnych — podręczny wykaz.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Matches Metoda użyje obliczanie z opóźnieniem, aby wypełnić zwracanego MatchCollection obiektu.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Uzyskiwanie dostępu do członków tej kolekcji, takie jak MatchCollection.Count i MatchCollection.CopyTo powoduje, że kolekcja wypełniona natychmiast.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Aby móc korzystać z opóźnieniem, powinien iteracji kolekcji za pomocą konstrukcji, takich jak foreach w języku C# i 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 w języku Visual Basic.in Visual Basic.

Ze względu na jego obliczanie leniwe wywoływania Matches(String) metoda zgłasza RegexMatchTimeoutException wyjątku.Because of its lazy evaluation, calling the Matches(String) method does not throw a RegexMatchTimeoutException exception. Jednak wyjątek jest zgłaszany, gdy operacja jest wykonywana na MatchCollection obiektu zwróconego przez tę metodę, jeśli MatchTimeout właściwość nie jest Regex.InfiniteMatchTimeout i operacji dopasowywania przekroczy ten interwał limitu czasu.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.

Zobacz też

Matches(String, Int32) Matches(String, Int32) Matches(String, Int32) Matches(String, Int32)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia wyrażeń regularnych, zaczynając od określonej pozycji początkowej w ciągu.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

Parametry

input
String String String String

Ciąg do wyszukania pod kątem dopasowania.The string to search for a match.

startat
Int32 Int32 Int32 Int32

Pozycja znaku w ciągu wejściowym, od którego należy rozpocząć wyszukiwanie.The character position in the input string at which to start the search.

Zwraca

Kolekcja Match obiekty znalezione przez wyszukiwanie.A collection of the Match objects found by the search. Jeśli nie znaleziono żadnych dopasowań, metoda zwraca obiekt pustą kolekcję.If no matches are found, the method returns an empty collection object.

Wyjątki

startat jest mniejsza od zera lub większa niż długość input.startat is less than zero or greater than the length of input.

Przykłady

W poniższym przykładzie użyto Match(String) metody do znalezienia pierwszego wyrazu w zdaniu, który kończy się na "es", a następnie wywołuje Matches(String, Int32) metodę, aby zidentyfikować dodatkowe słowa, które kończą się na "es".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

Definicję wzorca wyrażenia regularnego \b\w+es\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b\w+es\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
es Jest zgodny z ciągiem literału "es".Match the literal string "es".
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Uwagi

Matches(String, Int32) Metoda jest podobna do Match(String, Int32) znaleziono metody, z wyjątkiem, że zwraca informacje na temat wszystkie dopasowania w ciągu wejściowym, a nie pojedyncze dopasowanie.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. Odpowiada to następującemu kodowi: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  

Wzorzec wyrażenia regularnego, dla którego Matches(String, Int32) metoda wyszukiwania jest definiowany przez wywołanie jednej z Regex klasy konstruktorów.The regular expression pattern for which the Matches(String, Int32) method searches is defined by the call to one of the Regex class constructors. Aby uzyskać więcej informacji na temat elementy tworzące wzorzec wyrażenia regularnego, zobacz język wyrażeń regularnych — podręczny wykaz.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Matches Metoda użyje obliczanie z opóźnieniem, aby wypełnić zwracanego MatchCollection obiektu.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Uzyskiwanie dostępu do członków tej kolekcji, takie jak MatchCollection.Count i MatchCollection.CopyTo powoduje, że kolekcja wypełniona natychmiast.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Aby móc korzystać z opóźnieniem, powinien iteracji kolekcji za pomocą konstrukcji, takich jak foreach w języku C# i 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 w języku Visual Basic.in Visual Basic.

Ze względu na jego obliczanie leniwe wywoływania Matches(String, Int32) metoda zgłasza RegexMatchTimeoutException wyjątku.Because of its lazy evaluation, calling the Matches(String, Int32) method does not throw a RegexMatchTimeoutException exception. Jednak wyjątek jest zgłaszany, gdy operacja jest wykonywana na MatchCollection obiektu zwróconego przez tę metodę, jeśli MatchTimeout właściwość nie jest Regex.InfiniteMatchTimeout i operacji dopasowywania przekroczy ten interwał limitu czasu.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.

Zobacz też

Matches(String, String) Matches(String, String) Matches(String, String) Matches(String, String)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego.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

Parametry

input
String String String String

Ciąg do wyszukania pod kątem dopasowania.The string to search for a match.

pattern
String String String String

Wzorzec wyrażenia regularnego do dopasowania.The regular expression pattern to match.

Zwraca

Kolekcja Match obiekty znalezione przez wyszukiwanie.A collection of the Match objects found by the search. Jeśli nie znaleziono żadnych dopasowań, metoda zwraca obiekt pustą kolekcję.If no matches are found, the method returns an empty collection object.

Wyjątki

Wystąpił błąd analizowania wyrażenia regularnego.A regular expression parsing error occurred.

input lub pattern jest null.input or pattern is null.

Przykłady

W poniższym przykładzie użyto Matches(String, String) metodę, aby zidentyfikować wszelkie wyrazu w zdaniu, który kończy się na "es".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

Definicję wzorca wyrażenia regularnego \b\w+es\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b\w+es\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
es Jest zgodny z ciągiem literału "es".Match the literal string "es".
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Uwagi

Matches(String, String) Metoda jest podobna do Match(String, String) znaleziono metody, z wyjątkiem, że zwraca informacje na temat wszystkie dopasowania w ciągu wejściowym, a nie pojedyncze dopasowanie.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. Odpowiada to następującemu kodowi: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  

Statyczne Matches metody są równoważne do konstruowania Regex obiektu za pomocą wzorca określonego wyrażenia regularnego i wywołanie metody wystąpienia Matches.The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

pattern Parametr składa się z elementy języka wyrażeń regularnych, które opisują symbolicznie ciąg do dopasowania.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz wyrażeń regularnych programu .NET Framework i język wyrażeń regularnych — podręczny wykaz.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Matches Metoda użyje obliczanie z opóźnieniem, aby wypełnić zwracanego MatchCollection obiektu.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Uzyskiwanie dostępu do członków tej kolekcji, takie jak MatchCollection.Count i MatchCollection.CopyTo powoduje, że kolekcja wypełniona natychmiast.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Aby móc korzystać z opóźnieniem, powinien iteracji kolekcji za pomocą konstrukcji, takich jak foreach w języku C# i 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 w języku Visual Basic.in Visual Basic.

Ze względu na jego obliczanie leniwe wywoływania Matches(String, String) metoda zgłasza RegexMatchTimeoutException wyjątku.Because of its lazy evaluation, calling the Matches(String, String) method does not throw a RegexMatchTimeoutException exception. Jednak wyjątek jest zgłaszany, gdy operacja jest wykonywana na MatchCollection obiektu zwróconego przez tę metodę, jeśli interwał limitu czasu jest definiowany przez właściwość "REGEX_DEFAULT_MATCH_TIMEOUT" w bieżącej domenie aplikacji i operacji dopasowywania przekroczy ten interwał limitu czasu.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.

Uwagi dotyczące wywoływania

Ta metoda upłynie limit czasu po upływie interwału, który jest równa wartości limitu czasu domyślnej domeny aplikacji, w którym jest wywoływana.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. Jeśli nie określono wartość limitu czasu dla domeny aplikacji, a wartość InfiniteMatchTimeout, co uniemożliwia z przekroczeniem limitu czasu, metoda jest używana.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. Zalecaną metodą statycznego jest zgodna z Pobieranie wielu wzorzec jest Matches(String, String, RegexOptions, TimeSpan), które pozwalają określić interwał limitu czasu.The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you specify the time-out interval.

Zobacz też

Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego, przy użyciu określonych opcji dopasowania.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

Parametry

input
String String String String

Ciąg do wyszukania pod kątem dopasowania.The string to search for a match.

pattern
String String String String

Wzorzec wyrażenia regularnego do dopasowania.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Bitowa kombinacja wartości wyliczenia, które określają opcje do dopasowania.A bitwise combination of the enumeration values that specify options for matching.

Zwraca

Kolekcja Match obiekty znalezione przez wyszukiwanie.A collection of the Match objects found by the search. Jeśli nie znaleziono żadnych dopasowań, metoda zwraca obiekt pustą kolekcję.If no matches are found, the method returns an empty collection object.

Wyjątki

Wystąpił błąd analizowania wyrażenia regularnego.A regular expression parsing error occurred.

input lub pattern jest null.input or pattern is null.

options nie jest prawidłową kombinację bitowe RegexOptions wartości.options is not a valid bitwise combination of RegexOptions values.

Przykłady

Poniższy przykład wywołuje Matches(String, String) metodę identyfikowania dowolny wyraz w zdaniu, który kończy się na "es", a następnie wywołuje Matches(String, String, RegexOptions) metodę w celu porównania bez uwzględniania wielkości wzorzec ciągu wejściowego.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. Dane wyjściowe pokazują, te dwie metody zwracają różne wyniki.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

Definicję wzorca wyrażenia regularnego \b\w+es\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b\w+es\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
es Jest zgodny z ciągiem literału "es".Match the literal string "es".
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Uwagi

Matches(String, String, RegexOptions) Metoda jest podobna do Match(String, String, RegexOptions) znaleziono metody, z wyjątkiem, że zwraca informacje na temat wszystkie dopasowania w ciągu wejściowym, a nie pojedyncze dopasowanie.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. Odpowiada to następującemu kodowi: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  

Statyczne Matches metody są równoważne do konstruowania Regex obiektu za pomocą wzorca określonego wyrażenia regularnego i wywołanie metody wystąpienia Matches.The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

pattern Parametr składa się z elementy języka wyrażeń regularnych, które opisują symbolicznie ciąg do dopasowania.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz wyrażeń regularnych programu .NET Framework i język wyrażeń regularnych — podręczny wykaz.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Matches Metoda użyje obliczanie z opóźnieniem, aby wypełnić zwracanego MatchCollection obiektu.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Uzyskiwanie dostępu do członków tej kolekcji, takie jak MatchCollection.Count i MatchCollection.CopyTo powoduje, że kolekcja wypełniona natychmiast.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Aby móc korzystać z opóźnieniem, powinien iteracji kolekcji za pomocą konstrukcji, takich jak foreach w języku C# i 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 w języku Visual Basic.in Visual Basic.

Ze względu na jego obliczanie leniwe wywoływania Matches(String, String) metoda zgłasza RegexMatchTimeoutException wyjątku.Because of its lazy evaluation, calling the Matches(String, String) method does not throw a RegexMatchTimeoutException exception. Jednak wyjątek jest zgłaszany, gdy operacja jest wykonywana na MatchCollection obiektu zwróconego przez tę metodę, jeśli interwał limitu czasu jest definiowany przez właściwość "REGEX_DEFAULT_MATCH_TIMEOUT" w bieżącej domenie aplikacji i operacji dopasowywania przekroczy ten interwał limitu czasu.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.

Uwagi dotyczące wywoływania

Ta metoda upłynie limit czasu po upływie interwału, który jest równa wartości limitu czasu domyślnej domeny aplikacji, w którym jest wywoływana.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. Jeśli nie określono wartość limitu czasu dla domeny aplikacji, a wartość InfiniteMatchTimeout, co uniemożliwia z przekroczeniem limitu czasu, metoda jest używana.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. Zalecaną metodą statycznego jest zgodna z Pobieranie wielu wzorzec jest Matches(String, String, RegexOptions, TimeSpan), która pozwala ustawić interwał limitu czasu.The recommended static method for retrieving multiple pattern matches is Matches(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Zobacz też

Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego, przy użyciu określonego dopasowania interwał opcje i limitu czasu.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

Parametry

input
String String String String

Ciąg do wyszukania pod kątem dopasowania.The string to search for a match.

pattern
String String String String

Wzorzec wyrażenia regularnego do dopasowania.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Bitowa kombinacja wartości wyliczenia, które określają opcje do dopasowania.A bitwise combination of the enumeration values that specify options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Interwał limitu czasu lub InfiniteMatchTimeout do wskazania, że metoda powinna nie przekraczają limit czasu.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Zwraca

Kolekcja Match obiekty znalezione przez wyszukiwanie.A collection of the Match objects found by the search. Jeśli nie znaleziono żadnych dopasowań, metoda zwraca obiekt pustą kolekcję.If no matches are found, the method returns an empty collection object.

Wyjątki

Wystąpił błąd analizowania wyrażenia regularnego.A regular expression parsing error occurred.

input lub pattern jest null.input or pattern is null.

options nie jest prawidłową kombinację bitowe RegexOptions wartości.options is not a valid bitwise combination of RegexOptions values.

—lub—-or- matchTimeout ma wartość ujemną, zerowego, lub większa od około 24 dni.matchTimeout is negative, zero, or greater than approximately 24 days.

Przykłady

Poniższy przykład wywołuje Matches(String, String, RegexOptions, TimeSpan) metodę w celu porównania uwzględniającego wielkość liter, która jest dopasowywany dowolny wyraz w zdaniu, który kończy się na "es".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". Następnie wywołuje Matches(String, String, RegexOptions, TimeSpan) metodę w celu porównania bez uwzględniania wielkości wzorzec ciągu wejściowego.It then calls the Matches(String, String, RegexOptions, TimeSpan) method to perform a case-insensitive comparison of the pattern with the input string. W obu przypadkach interwał limitu czasu jest równa 1 sekundy.In both cases, the time-out interval is set to one second. Dane wyjściowe pokazują, te dwie metody zwracają różne wyniki.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

Definicję wzorca wyrażenia regularnego \b\w+es\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b\w+es\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
es Jest zgodny z ciągiem literału "es".Match the literal string "es".
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Uwagi

Matches(String, String, RegexOptions, TimeSpan) Metoda jest podobna do Match(String, String, RegexOptions, TimeSpan) znaleziono metody, z wyjątkiem, że zwraca informacje na temat wszystkie dopasowania w ciągu wejściowym, a nie pojedyncze dopasowanie.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. Odpowiada to następującemu kodowi: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   

Statyczne Matches metody są równoważne do konstruowania Regex obiektu za pomocą wzorca określonego wyrażenia regularnego i wywołanie metody wystąpienia Matches.The static Matches methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Matches.

pattern Parametr składa się z elementy języka wyrażeń regularnych, które opisują symbolicznie ciąg do dopasowania.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz wyrażeń regularnych programu .NET Framework i język wyrażeń regularnych — podręczny wykaz.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Matches Metoda użyje obliczanie z opóźnieniem, aby wypełnić zwracanego MatchCollection obiektu.The Matches method uses lazy evaluation to populate the returned MatchCollection object. Uzyskiwanie dostępu do członków tej kolekcji, takie jak MatchCollection.Count i MatchCollection.CopyTo powoduje, że kolekcja wypełniona natychmiast.Accessing members of this collection such as MatchCollection.Count and MatchCollection.CopyTo causes the collection to be populated immediately. Aby móc korzystać z opóźnieniem, powinien iteracji kolekcji za pomocą konstrukcji, takich jak foreach w języku C# i 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 w języku Visual Basic.in Visual Basic.

Ze względu na jego obliczanie leniwe wywoływania Matches metoda zgłasza RegexMatchTimeoutException wyjątku.Because of its lazy evaluation, calling the Matches method does not throw a RegexMatchTimeoutException exception. Jednak wyjątek jest zgłaszany, gdy operacja jest wykonywana na MatchCollection obiektu zwróconego przez tę metodę, jeśli operacja przekroczy ten interwał limitu czasu określonego przezmatchTimeout parametru.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.

Uwagi dotyczące wywoływania

Firma Microsoft zaleca, aby ustawić matchTimeout parametru do odpowiedniej wartości, takich jak dwóch sekund.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeout, aparat wyrażeń regularnych zapewnia nieco większą wydajność.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Jednakże należy wyłączyć limity czasu tylko w następujących warunkach:However, you should disable time-outs only under the following conditions: — W przypadku danych wejściowych, przetwarzane przez wyrażenie regularne jest pochodną znanego i zaufanego źródła lub zawiera tekst statyczny.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Nie obejmuje to tekst, który znajduje się dynamicznie danych wprowadzonych przez użytkowników.This excludes text that has been dynamically input by users.

— Jeśli wzorzec wyrażenia regularnego dokładnie przetestowano upewnij się, że umożliwia ona efektywne obsługę, bez dopasowania i wkrótce.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

— W przypadku wzorca wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane, aby spowodować, że nadmierne używanie wycofywania podczas przetwarzania niemal dopasowania.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Zobacz też

Dotyczy