Regex.Matches Metoda

Reference

Definice

Obor názvů:: System.Text.RegularExpressions

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vyhledá vstupní řetězec pro všechny výskyty regulárního výrazu a vrátí všechny shody.

Přetížení

Matches(String, String, RegexOptions, TimeSpan)	Vyhledá v zadaném vstupním řetězci všechny výskyty zadaného regulárního výrazu pomocí zadaných odpovídajících možností a intervalu časového limitu.
Matches(String, String, RegexOptions)	Vyhledá v zadaném vstupním řetězci všechny výskyty zadaného regulárního výrazu pomocí zadaných odpovídajících možností.
Matches(String, Int32)	Vyhledá v zadaném vstupním řetězci všechny výskyty regulárního výrazu počínaje zadanou počáteční pozicí v řetězci.
Matches(String)	Vyhledá v zadaném vstupním řetězci všechny výskyty regulárního výrazu.
Matches(String, String)	Vyhledá v zadaném vstupním řetězci všechny výskyty zadaného regulárního výrazu.

Matches(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Vyhledá v zadaném vstupním řetězci všechny výskyty zadaného regulárního výrazu pomocí zadaných odpovídajících možností a intervalu časového limitu.

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

Řetězec, který hledá shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

options: RegexOptions

Bitové kombinace hodnot výčtu, které určují možnosti pro porovnávání.

matchTimeout: TimeSpan

Časový limit nebo InfiniteMatchTimeout označující, že by nemělo dojít k vypršení časového limitu metody.

Návraty

MatchCollection

Kolekce Match objektů nalezených při hledání. Pokud nejsou nalezeny žádné shody, vrátí metoda prázdný objekt kolekce.

Výjimky

ArgumentException

Při analýze regulárního výrazu došlo k chybě.

ArgumentNullException

input nebo pattern je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

-nebo-

matchTimeout je záporná, nulová nebo větší než přibližně 24 dnů.

Příklady

Následující příklad volá metodu Matches(String, String, RegexOptions, TimeSpan) k provedení porovnání s rozlišováním malých a velkých písmen, které odpovídá libovolnému slovu ve větě, která končí na "es". Potom zavolá metodu Matches(String, String, RegexOptions, TimeSpan) k provedení porovnání vzoru se vstupním řetězcem, které nerozlišují malá a velká písmena. V obou případech je časový limit nastavený na jednu sekundu. Jak ukazuje výstup, tyto dvě metody vrací různé výsledky.

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

Vzor \b\w+es\b regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor	Description
`\b`	Začne porovnání na hranici slova.
`\w+`	Porovná jeden nebo více znaků slova.
`es`	Odpovídá řetězci literálu "es".
`\b`	Ukončí porovnání na hranici slova.

Poznámky

Metoda Matches(String, String, RegexOptions, TimeSpan) je podobná metodě s tím rozdílem Match(String, String, RegexOptions, TimeSpan) , že místo jedné shody vrací informace o všech shodách nalezených ve vstupním řetězci. Je ekvivalentní k následujícímu kódu:

   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

Statické Matches metody jsou ekvivalentní ke konstrukci objektu Regex se zadaným vzorem regulárního výrazu a volání metody Matchesinstance .

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a jazyk regulárních výrazů – stručné referenční informace.

Metoda Matches používá opožděné vyhodnocení k naplnění vráceného MatchCollection objektu. Přístup ke členům této kolekce, například MatchCollection.Count a MatchCollection.CopyTo , způsobí okamžité naplnění kolekce. Pokud chcete využít opožděné vyhodnocení, měli byste kolekci iterovat pomocí konstruktoru, například foreach v jazyce C# a For Each...Next v jazyce Visual Basic.

Z důvodu opožděného vyhodnocení volání Matches metody nevyvolá RegexMatchTimeoutException výjimku. Při provedení operace s MatchCollection objektem vráceným touto metodou však dojde k výjimce, pokud odpovídající operace překročí tento interval časového limitu určeného parametremmatchTimeout .

Poznámky pro volající

Doporučujeme nastavit parametr na matchTimeout odpovídající hodnotu, například dvě sekundy. Pokud časové limity zakážete zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí o něco lepší výkon. Časové limity byste ale měli zakázat pouze za následujících podmínek:

Když je vstup zpracovaný regulárním výrazem odvozen ze známého a důvěryhodného zdroje nebo se skládá ze statického textu. Tím se vyloučí text, který uživatelé zadali dynamicky.
Když byl vzor regulárního výrazu důkladně otestován, aby se zajistilo, že efektivně zpracovává shody, neshody a blízké shody.
Když vzor regulárního výrazu neobsahuje žádné elementy jazyka, o kterých je známo, že způsobují nadměrné navracení při zpracování téměř shody.

Viz také

Elementy jazyka regulárních výrazů

Platí pro

Matches(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Vyhledá v zadaném vstupním řetězci všechny výskyty zadaného regulárního výrazu pomocí zadaných odpovídajících možností.

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

Řetězec, který hledá shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

options: RegexOptions

Bitové kombinace hodnot výčtu, které určují možnosti pro porovnávání.

Návraty

MatchCollection

Kolekce Match objektů nalezených při hledání. Pokud nejsou nalezeny žádné shody, vrátí metoda prázdný objekt kolekce.

Výjimky

ArgumentException

Při analýze regulárního výrazu došlo k chybě.

ArgumentNullException

input nebo pattern je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

Příklady

Následující příklad volá metodu Matches(String, String) k identifikaci jakéhokoli slova ve větě, která končí na "es", a pak zavolá metodu Matches(String, String, RegexOptions) k provedení porovnání vzoru se vstupním řetězcem, které nerozlišují malá a velká písmena. Jak ukazuje výstup, tyto dvě metody vrací různé výsledky.

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

Vzor \b\w+es\b regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor	Description
`\b`	Začne porovnání na hranici slova.
`\w+`	Porovná jeden nebo více znaků slova.
`es`	Odpovídá řetězci literálu "es".
`\b`	Ukončí porovnání na hranici slova.

Poznámky

Metoda Matches(String, String, RegexOptions) je podobná metodě s tím rozdílem Match(String, String, RegexOptions) , že místo jedné shody vrací informace o všech shodách nalezených ve vstupním řetězci. Je ekvivalentní k následujícímu kódu:

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

Statické Matches metody jsou ekvivalentní ke konstrukci objektu Regex se zadaným vzorem regulárního výrazu a volání metody Matchesinstance .

Z důvodu opožděného vyhodnocení volání Matches(String, String) metody nevyvolá RegexMatchTimeoutException výjimku. Výjimka je však vyvolán při provedení operace s MatchCollection objektem vráceným touto metodou, pokud je časový limit definovaný vlastností "REGEX_DEFAULT_MATCH_TIMEOUT" aktuální domény aplikace a odpovídající operace překročí tento interval časového limitu.

Poznámky pro volající

Tato metoda vyprší časový limit po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána. Pokud pro doménu aplikace nebyla definována hodnota časového limitu, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučenou statickou metodou pro načtení více shod vzorů je Matches(String, String, RegexOptions, TimeSpan), která umožňuje nastavit interval časového limitu.

Viz také

Elementy jazyka regulárních výrazů

Platí pro

Matches(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Vyhledá v zadaném vstupním řetězci všechny výskyty regulárního výrazu počínaje zadanou počáteční pozicí v řetězci.

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

Řetězec, který hledá shodu.

startat: Int32

Pozice znaku ve vstupním řetězci, na kterém má být zahájeno hledání.

Návraty

MatchCollection

Kolekce Match objektů nalezených při hledání. Pokud nejsou nalezeny žádné shody, vrátí metoda prázdný objekt kolekce.

Výjimky

ArgumentNullException

input je null.

ArgumentOutOfRangeException

startatje menší než nula nebo větší než délka .input

Příklady

Následující příklad používá metodu Match(String) k vyhledání prvního slova ve větě, která končí na "es", a pak zavolá metodu Matches(String, Int32) k identifikaci všech dalších slov, která končí na "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

Vzor \b\w+es\b regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor	Description
`\b`	Začne porovnání na hranici slova.
`\w+`	Porovná jeden nebo více znaků slova.
`es`	Odpovídá řetězci literálu "es".
`\b`	Ukončí porovnání na hranici slova.

Poznámky

Metoda Matches(String, Int32) je podobná metodě s tím rozdílem Match(String, Int32) , že místo jedné shody vrací informace o všech shodách nalezených ve vstupním řetězci. Je ekvivalentní k následujícímu kódu:

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

Vzor regulárního výrazu Matches(String, Int32) , pro který metoda hledá, je definován voláním jednoho z Regex konstruktorů třídy. Další informace o elementech, které mohou vytvořit vzor regulárního výrazu, najdete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.

Další podrobnosti o startatnástroji najdete v části Poznámky v souboru Match(String, Int32).

Z důvodu opožděného vyhodnocení volání Matches(String, Int32) metody nevyvolá RegexMatchTimeoutException výjimku. Výjimka je však vyvolán, když se provede operace s MatchCollection objektem vráceným touto metodou, pokud MatchTimeout vlastnost není Regex.InfiniteMatchTimeout a odpovídající operace překročí interval časového limitu.

Viz také

Elementy jazyka regulárních výrazů

Platí pro

Matches(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Vyhledá zadaný vstupní řetězec pro všechny výskyty regulárního výrazu.

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

Řetězec, který má vyhledat shodu.

Návraty

MatchCollection

Kolekce Match objektů nalezených při hledání. Pokud nejsou nalezeny žádné shody, vrátí metoda prázdný objekt kolekce.

Výjimky

ArgumentNullException

input je null.

Příklady

Následující příklad používá metodu Matches(String) k identifikaci všech slov ve větě, která končí na "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

Vzor \b\w+es\b regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor	Description
`\b`	Začne porovnání na hranici slova.
`\w+`	Porovná jeden nebo více znaků slova.
`es`	Porovná řetězec literálu "es".
`\b`	Ukončí porovnání na hranici slova.

Poznámky

Metoda Matches(String) je podobná metodě s tím rozdílem Match(String) , že místo jedné shody vrací informace o všech shodách nalezených ve vstupním řetězci. Je ekvivalentní k následujícímu kódu:

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

Kolekce obsahuje pouze shody a ukončí se při prvním neshodě.

Vzor regulárního výrazu Matches(String) , pro který metoda hledá, je definován voláním jednoho z Regex konstruktorů třídy. Další informace o elementech, které mohou vytvořit vzor regulárního výrazu, najdete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.

Z důvodu opožděného vyhodnocení volání Matches(String) metody nevyvolá RegexMatchTimeoutException výjimku. Výjimka je však vyvolán, když se provede operace s MatchCollection objektem vráceným touto metodou, pokud MatchTimeout vlastnost není Regex.InfiniteMatchTimeout a odpovídající operace překročí interval časového limitu.

Viz také

Elementy jazyka regulárních výrazů

Platí pro

Matches(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Vyhledá zadaný vstupní řetězec pro všechny výskyty zadaného regulárního výrazu.

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

Řetězec, který má vyhledat shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

Návraty

MatchCollection

Kolekce Match objektů nalezených při hledání. Pokud nejsou nalezeny žádné shody, vrátí metoda prázdný objekt kolekce.

Výjimky

ArgumentException

Došlo k chybě parsování regulárního výrazu.

ArgumentNullException

input nebo pattern je null.

Příklady

Následující příklad používá metodu Matches(String, String) k identifikaci libovolného slova ve větě, která končí na "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

Vzor \b\w+es\b regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor	Description
`\b`	Začne porovnání na hranici slova.
`\w+`	Porovná jeden nebo více znaků slova.
`es`	Porovná řetězec literálu "es".
`\b`	Ukončí porovnání na hranici slova.

Poznámky

Metoda Matches(String, String) je podobná metodě s tím rozdílem Match(String, String) , že místo jedné shody vrací informace o všech shodách nalezených ve vstupním řetězci. Je ekvivalentní k následujícímu kódu:

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

Statické Matches metody jsou ekvivalentní k vytvoření objektu Regex se zadaným vzorem regulárního výrazu a volání metody Matchesinstance .

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a Jazyk regulárních výrazů – stručná referenční příručka.

Z důvodu opožděného vyhodnocení volání Matches(String, String) metody nevyvolá RegexMatchTimeoutException výjimku. Výjimka je však vyvolán, když se provede operace s MatchCollection objektem vráceným touto metodou, pokud je časový limit definován vlastností "REGEX_DEFAULT_MATCH_TIMEOUT" aktuální domény aplikace a odpovídající operace překročí tento interval časového limitu.

Poznámky pro volající

Časový limit této metody vyprší po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána. Pokud hodnota časového limitu nebyla definována pro doménu aplikace, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučená statická metoda pro načtení více shod vzorů je Matches(String, String, RegexOptions, TimeSpan), která umožňuje určit interval časového limitu.

Viz také

Elementy jazyka regulárních výrazů

Platí pro

Regex.Matches Metoda

Definice

Přetížení

Matches(String, String, RegexOptions, TimeSpan)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Matches(String, String, RegexOptions)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Matches(String, Int32)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Matches(String)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Matches(String, String)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Váš názor

Další materiály