Regex.Matches Metoda

Zdroj:

Regex.Match.cs

Zdroj:

Regex.Match.cs

Zdroj:

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

Parametry

Návraty

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

Výjimky

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.

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ů

Zdroj:

Regex.Match.cs

Zdroj:

Regex.Match.cs

Zdroj:

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

Parametry

Návraty

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

Výjimky

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.

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 .

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(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ů

Zdroj:

Regex.Match.cs

Zdroj:

Regex.Match.cs

Zdroj:

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

Parametry

Návraty

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

Výjimky

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.

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).

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(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ů

Zdroj:

Regex.Match.cs

Zdroj:

Regex.Match.cs

Zdroj:

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

Parametry

Návraty

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

Výjimky

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.

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.

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(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ů

Zdroj:

Regex.Match.cs

Zdroj:

Regex.Match.cs

Zdroj:

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

Parametry

Návraty

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

Výjimky

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.

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.

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(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ů