Regex.Match Metoda

Definice

Obor názvů:

System.Text.RegularExpressions

Sestavení:

System.Text.RegularExpressions.dll

Vyhledá vstupní řetězec podřetězce, který odpovídá vzoru regulárního výrazu, a vrátí první výskyt jako jeden Match objekt.

Přetížení

Match(String)	Vyhledá zadaný vstupní řetězec pro první výskyt regulárního výrazu zadaného v konstruktoru Regex.
Match(String, Int32)	Vyhledá vstupní řetězec pro první výskyt regulárního výrazu počínaje zadanou počáteční pozicí v řetězci.
Match(String, String)	Vyhledá zadaný vstupní řetězec pro první výskyt zadaného regulárního výrazu.
Match(String, Int32, Int32)	Vyhledá vstupní řetězec pro první výskyt regulárního výrazu, který začíná na zadané počáteční pozici a hledá pouze zadaný počet znaků.
Match(String, String, RegexOptions)	Vyhledá vstupní řetězec pro první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností.
Match(String, String, RegexOptions, TimeSpan)	Vyhledá vstupní řetězec pro první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností a intervalu časového limitu.

Match(String)

Zdroj:

Regex.Match.cs

Vyhledá zadaný vstupní řetězec pro první výskyt regulárního výrazu zadaného v konstruktoru Regex.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);

public System.Text.RegularExpressions.Match Match (string input);

member this.Match : string -> System.Text.RegularExpressions.Match

Public Function Match (input As String) As Match

Parametry

input

String

Řetězec, který chcete vyhledat shodu.

Návraty

Match

Objekt, který obsahuje informace o shodě.

Výjimky

ArgumentNullException

input je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad najde shodu vzorů regulárních výrazů v řetězci a pak zobrazí odpovídající skupiny, zachycení a zachycení pozic.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

using System;
using System.Text.RegularExpressions;

class Example
{
   static void Main()
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);

      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success)
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++)
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++)
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Vzor regulárního výrazu (\w+)\s+(car) odpovídá výskytům slova "car" spolu se slovem, které mu předchází. Interpretuje se, jak je znázorněno v následující tabulce.

Vzor	Popis
(\w+)	Porovná jeden nebo více znaků slova. Toto je první zachycená skupina.
\s+	Porovná jeden nebo více prázdných znaků.
(auto)	Porovná řetězec literálu "car". Toto je druhá skupina zachycení.

Poznámky

Metoda Match(String) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka používaných k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční.

Vzor regulárního výrazu lze zjistit ve vstupním řetězci tak, že zkontrolujete hodnotu vrácené vlastnosti Match objektu Success. Pokud se najde shoda, vrácená vlastnost Match objektu Value obsahuje podřetězení z input, která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, její hodnota se String.Empty.

Tato metoda vrátí první podřetětěr v input, který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním vrácené metody Match objektu Match.NextMatch. Můžete také načíst všechny shody v jednom volání metody voláním Regex.Matches(String) metody.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překračuje časový limit určený konstruktorem Regex.Regex(String, RegexOptions, TimeSpan). Pokud při volání konstruktoru nenastavíte časový limit, vyvolá se výjimka, pokud operace překročí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován žádný časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Viz také

• NextMatch()
• jazyk regulárních výrazů – stručná referenční

Match(String, Int32)

Zdroj:

Regex.Match.cs

Vyhledá vstupní řetězec pro první výskyt regulárního výrazu počínaje zadanou počáteční pozicí v řetězci.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);

public System.Text.RegularExpressions.Match Match (string input, int startat);

member this.Match : string * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, startat As Integer) As Match

Parametry

input

String

Řetězec, který chcete vyhledat shodu.

startat

Int32

Pozice znaku založeného na nule, na které se má hledání spustit.

Návraty

Match

Objekt, který obsahuje informace o shodě.

Výjimky

ArgumentNullException

input je null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Další informace o tomto rozhraní API naleznete v tématu Doplňkové poznámky k rozhraní API pro Regex.Match.

Viz také

• NextMatch()
• jazyk regulárních výrazů – stručná referenční

Match(String, String)

Zdroj:

Regex.Match.cs

Vyhledá zadaný vstupní řetězec pro první výskyt zadaného regulárního výrazu.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.Match Match (string input, string pattern);

static member Match : string * string -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String) As Match

Parametry

input

String

Řetězec, který chcete vyhledat shodu.

pattern

String

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

Návraty

Match

Objekt, který obsahuje informace o shodě.

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

input nebo pattern je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad volá metodu Match(String, String) k vyhledání prvního slova, které obsahuje alespoň jeden z znak, a potom zavolá metodu Match.NextMatch najít všechny další shody.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example
    {
        public static void Main()
        {
            string input = "ablaze beagle choral dozen elementary fanatic " +
                           "glaze hunger inept jazz kitchen lemon minus " +
                           "night optical pizza quiz restoration stamina " +
                           "train unrest vertical whiz xray yellow zealous";
            string pattern = @"\b\w*z+\w*\b";
            Match m = Regex.Match(input, pattern);
            while (m.Success)
            {
                Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
                m = m.NextMatch();
            }
        }
    }
}

// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

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

Vzor	Popis
\b	Zahajte shodu na hranici slova.
\w*	Porovná nulu, jednu nebo více znaků slova.
z+	Porovná jeden nebo více výskytů z znaku.
\w*	Porovná nulu, jednu nebo více znaků slova.
\b	Ukončete shodu na hranici slova.

Poznámky

Metoda Match(String, String) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka používaných k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční.

Static Match(String, String) metoda je ekvivalentní vytvoření Regex objektu se zadaným vzorem regulárního výrazu a voláním instance Match(String) metoda. V tomto případě modul regulárních výrazů ukládá vzor regulárního výrazu do mezipaměti.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

Vzor regulárního výrazu lze zjistit ve vstupním řetězci tak, že zkontrolujete hodnotu vrácené vlastnosti Match objektu Success. Pokud se najde shoda, vrácená vlastnost Match objektu Value obsahuje podřetězení z input, která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, její hodnota se String.Empty.

Tato metoda vrátí první podřetětěr v input, který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním vrácené metody Match objektu Match.NextMatch. Můžete také načíst všechny shody v jednom volání metody voláním Regex.Matches(String, String) metody.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překračuje časový limit zadaný pro doménu aplikace, ve které je volána metoda. Pokud není definován žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Poznámky pro volající

Tato metoda vyprší 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čená statická metoda pro načtení shody vzorů je Match(String, String), která umožňuje nastavit interval časového limitu.

Viz také

• NextMatch()
• jazyk regulárních výrazů – stručná referenční

Match(String, Int32, Int32)

Zdroj:

Regex.Match.cs

Vyhledá vstupní řetězec pro první výskyt regulárního výrazu, který začíná na zadané počáteční pozici a hledá pouze zadaný počet znaků.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);

public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);

member this.Match : string * int * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Parametry

input

String

Řetězec, který chcete vyhledat shodu.

beginning

Int32

Pozice znaku založená na nule ve vstupním řetězci, která definuje pozici nejvíce vlevo, která se má prohledávat.

length

Int32

Počet znaků v podřetědci, které se mají zahrnout do hledání.

Návraty

Match

Objekt, který obsahuje informace o shodě.

Výjimky

ArgumentNullException

input je null.

ArgumentOutOfRangeException

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

-nebo-

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

-nebo-

beginning + length -1 identifikuje pozici mimo rozsah input.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metoda Match(String, Int32, Int32) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu v části vstupního řetězce. Informace o elementech jazyka používaných k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční.

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

Metoda Match(String, Int32, Int32) prohledá část input definované beginning a length parametry pro vzor regulárního výrazu. beginning vždy definuje index znaku úplně vlevo, který se má zahrnout do hledání, a length definuje maximální počet znaků, které se mají prohledávat. Společně definují rozsah hledání. Chování je přesně stejné, jako kdyby input bylo účinně input.Substring(beginning, length), s tím rozdílem, že index jakékoli shody je počítána vzhledem k začátku input. To znamená, že se všechna ukotvení nebo kontrolní výrazy nulové šířky na začátku nebo konci vzoru chovají, jako by v tomto rozsahu nebyly žádné input. Například kotvy ^, \Ga \A budou spokojeny v beginning a $ a \z budou spokojeny v beginning + length - 1.

Pokud hledání pokračuje zleva doprava (výchozí), modul regulárních výrazů prohledá z znaku indexu beginning na znak v indexu beginning + length - 1. Pokud modul regulárních výrazů vytvořil instanci pomocí možnosti RegexOptions.RightToLeft tak, aby vyhledávání probíhalo zprava doleva, modul regulárních výrazů prohledává z znaku indexu beginning + length - 1 na znak v indexu beginning.

Tato metoda vrátí první shodu, kterou najde v rámci tohoto rozsahu. Následné shody můžete načíst opakovaným voláním vrácené metody Match objektu Match.NextMatch.

Vzor regulárního výrazu lze zjistit ve vstupním řetězci tak, že zkontrolujete hodnotu vrácené vlastnosti Match objektu Success. Pokud se najde shoda, vrácená vlastnost Match objektu Value obsahuje podřetězení z input, která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, její hodnota se String.Empty.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překračuje časový limit určený konstruktorem Regex.Regex(String, RegexOptions, TimeSpan). Pokud při volání konstruktoru nenastavíte hodnotu časového limitu, vyvolá se výjimka, pokud operace překročí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován žádný časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Viz také

• NextMatch()
• jazyk regulárních výrazů – stručná referenční

Match(String, String, RegexOptions)

Zdroj:

Regex.Match.cs

Vyhledá vstupní řetězec pro první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Parametry

input

String

Řetězec, který chcete vyhledat shodu.

pattern

String

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

options

RegexOptions

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

Návraty

Match

Objekt, který obsahuje informace o shodě.

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

input nebo pattern je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad definuje regulární výraz, který odpovídá slovům začínajícím písmenem "a". Používá možnost RegexOptions.IgnoreCase k zajištění toho, aby regulární výraz vyhledá slova začínající velkými písmeny "a" i malými písmeny "a".

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        public static void Main()
        {
            string pattern = @"\ba\w*\b";
            string input = "An extraordinary day dawns with each new day.";
            Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            if (m.Success)
                Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
        }
    }
}

// The example displays the following output:
//        Found 'An' at position 0.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

Vzor regulárního výrazu \ba\w*\b je interpretován, jak je znázorněno v následující tabulce.

Vzor	Popis
\b	Zahajte shodu na hranici slova.
a	Porovná znak "a".
\w*	Porovná nulu, jednu nebo více znaků slova.
\b	Ukončete shodu na hranici slova.

Poznámky

Metoda Match(String, String, RegexOptions) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka používaných k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční.

Static Match(String, String, RegexOptions) metoda je ekvivalentní vytvoření Regex objektu pomocí konstruktoru Regex(String, RegexOptions) a volání instance Match(String) metoda.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

Vzor regulárního výrazu lze zjistit ve vstupním řetězci tak, že zkontrolujete hodnotu vrácené vlastnosti Match objektu Success. Pokud se najde shoda, vrácená vlastnost Match objektu Value obsahuje podřetězení z input, která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, její hodnota se String.Empty.

Tato metoda vrátí první podřetětěr nalezený v input, který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním vrácené metody Match objektu NextMatch. Můžete také načíst všechny shody v jednom volání metody voláním Regex.Matches(String, String, RegexOptions) metody.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překračuje časový limit zadaný pro doménu aplikace, ve které je volána metoda. Pokud není definován žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Poznámky pro volající

Tato metoda vyprší 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čená statická metoda pro načtení shody vzorů je Match(String, String), která umožňuje nastavit interval časového limitu.

Viz také

• NextMatch()
• jazyk regulárních výrazů – stručná referenční

Match(String, String, RegexOptions, TimeSpan)

Zdroj:

Regex.Match.cs

Vyhledá vstupní řetězec pro první výskyt 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::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Parametry

input

String

Řetězec, který chcete vyhledat shodu.

pattern

String

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

options

RegexOptions

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

matchTimeout

TimeSpan

Časový limit nebo InfiniteMatchTimeout označující, že metoda by neměla časového limitu časového limitu.

Návraty

Match

Objekt, který obsahuje informace o shodě.

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

input nebo pattern je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

-nebo-

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

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metoda Match(String, String, RegexOptions, TimeSpan) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka používaných k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční.

Static Match(String, String, RegexOptions, TimeSpan) metoda je ekvivalentní vytvoření Regex objektu pomocí konstruktoru Regex(String, RegexOptions, TimeSpan) a volání instance Match(String) metoda.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

Vzor regulárního výrazu lze zjistit ve vstupním řetězci tak, že zkontrolujete hodnotu vrácené vlastnosti Match objektu Success. Pokud se najde shoda, vrácená vlastnost Match objektu Value obsahuje podřetězení z input, která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, její hodnota se String.Empty.

Tato metoda vrátí první podřetětěr nalezený v input, který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním vrácené metody Match objektu NextMatch. Můžete také načíst všechny shody v jednom volání metody voláním Regex.Matches(String, String, RegexOptions) metody.

Parametr matchTimeout určuje, jak dlouho se má metoda porovnávání vzorů pokusit najít shodu, než vyprší časový limit. Nastavení intervalu časového limitu brání regulárním výrazům, které spoléhají na nadměrné navracení, aby přestaly reagovat při zpracování vstupu, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a zpětného navracení . Pokud se v daném časovém intervalu nenajde žádná shoda, vyvolá metoda RegexMatchTimeoutException výjimku. matchTimeout přepíše výchozí hodnotu časového limitu definovanou pro doménu aplikace, ve které se metoda spouští.

Poznámky pro volající

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

• Pokud 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é dynamicky zadali.

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

• Pokud vzor regulárního výrazu neobsahuje žádné prvky jazyka, o kterých je známo, že při zpracování blízké shody způsobují nadměrné navracení.

Viz také

• jazyk regulárních výrazů – stručná referenční