Regex Třída

Definice

Představuje neměnný regulární výraz.

public ref class Regex
public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
type Regex = class
    interface ISerializable
[<System.Serializable>]
type Regex = class
    interface ISerializable
Public Class Regex
Public Class Regex
Implements ISerializable
Dědičnost
Regex
Odvozené
Atributy
Implementuje

Příklady

Následující příklad používá regulární výraz ke kontrole opakovaných výskytů slov v řetězci. Regulární výraz \b(?<word>\w+)\s+(\k<word>)\b lze interpretovat tak, jak je znázorněno v následující tabulce.

Vzor Popis
\b Zahájení shody na hranici slova
(?<word>\w+) Porovná jeden nebo více znaků slova až po hranici slova. Tuto zachycenou skupinu wordpojmenujte .
\s+ Porovná jeden nebo více prázdných znaků.
(\k<word>) Porovná zachycenou skupinu s názvem word.
\b Porovná hranici slova.
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumps over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}",
                          matches.Count,
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",
                              groups["word"].Value,
                              groups[0].Index,
                              groups[1].Index);
        }
    }
}

// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 49 and 53
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 49 and 53

Následující příklad ukazuje použití regulárního výrazu ke kontrole, zda řetězec představuje hodnotu měny nebo má správný formát představující hodnotu měny. V tomto případě je regulární výraz sestaven dynamicky z NumberFormatInfo.CurrencyDecimalSeparatorvlastností , CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSigna NumberFormatInfo.PositiveSign pro jazykovou verzi en-US. Výsledný regulární výraz je ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Tento regulární výraz lze interpretovat tak, jak je znázorněno v následující tabulce.

Vzor Popis
^ Začněte na začátku řetězce.
\s* Porovná žádný nebo více prázdných znaků.
[\+-]? Porovná žádný nebo jeden výskyt kladného nebo záporného znaménka.
\s? Porovná žádný nebo jeden prázdný znak.
\$? Porovná žádný nebo jeden výskyt znaku dolaru.
\s? Porovná žádný nebo jeden prázdný znak.
\d* Porovná žádnou nebo několik desítkových číslic.
\.? Porovná symbol nuly nebo jedné desetinné čárky.
(\d{2})? Zachycení skupiny 1: Porovná dvě desetinné číslice nula nebo jednou.
(\d*\.?(\d{2})?){1} Porovná vzor integrálních a desetinných číslic oddělených alespoň jednou symbolem desetinné čárky.
$ Porovná konec řetězce.

V tomto případě regulární výraz předpokládá, že platný řetězec měny neobsahuje symboly oddělovače skupin a že nemá buď žádné desetinné číslice, nebo počet desetinných míst definovaný vlastností zadané jazykové CurrencyDecimalDigits verze.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        // Get the en-US NumberFormatInfo object to build the regular 
        // expression pattern dynamically.
        NumberFormatInfo nfi = CultureInfo.GetCultureInfo("en-US").NumberFormat;

        // Define the regular expression pattern.
        string pattern;
        pattern = @"^\s*[";
        // Get the positive and negative sign symbols.
        pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
        // Get the currency symbol.
        pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
        // Add integral digits to the pattern.
        pattern += @"(\d*";
        // Add the decimal separator.
        pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
        // Add the fractional digits.
        pattern += @"(\d{";
        // Determine the number of fractional digits in currency values.
        pattern += nfi.CurrencyDecimalDigits.ToString() + "})?){1}$";

        Console.WriteLine($"Pattern is {pattern}\n");

        Regex rgx = new Regex(pattern);

        // Define some test strings.
        string[] tests = { "-42", "19.99", "0.001", "100 USD",
                         ".34", "0.34", "1,052.21", "$10.62",
                         "+1.43", "-$0.23" };

        // Check each test string against the regular expression.
        foreach (string test in tests)
        {
            if (rgx.IsMatch(test))
                Console.WriteLine($"{test} is a currency value.");
            else
                Console.WriteLine($"{test} is not a currency value.");
        }
    }
}
// The example displays the following output:
//       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
//
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = CultureInfo.GetCultureInfo("en-US").NumberFormat

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "(\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "})?){1}$"
      
      Console.WriteLine("Pattern is {0}", pattern)
      Console.WriteLine()
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
'
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

Vzhledem k tomu, že regulární výraz v tomto příkladu je sestaven dynamicky, v době návrhu nevíte, jestli může modul regulárních výrazů chybně interpretovat symbol měny, desetinné znaménko nebo kladné a záporné znaky zadané jazykové verze (v tomto příkladu en-US) jako operátory jazyka regulárních výrazů. Aby se zabránilo chybné interpretaci, předá příklad každý dynamicky generovaný řetězec metodě Escape .

Poznámky

Třída Regex představuje modul regulárních výrazů rozhraní .NET Framework. To lze použít k rychlé parsování velké množství textu najít konkrétní znakové vzory; extrahovat, upravit, nahradit nebo odstranit podřetěžce textu; a přidejte extrahované řetězce do kolekce, aby se vygenerovala sestava.

Poznámka

Pokud je vaším primárním zájmem ověřit řetězec určením, zda odpovídá určitému vzoru, můžete použít System.Configuration.RegexStringValidator třídu .

Chcete-li použít regulární výrazy, definujete vzor, který chcete identifikovat v textovém streamu, pomocí syntaxe popsané v tématu Jazyk regulárních výrazů – stručná referenční příručka. Dále můžete volitelně vytvořit instanci objektu Regex . Nakonec zavoláte metodu, která provádí určitou operaci, například nahrazení textu, který odpovídá vzoru regulárního výrazu, nebo identifikaci shody vzoru.

Poznámka

Některé běžné vzory regulárních výrazů najdete v tématu Příklady regulárních výrazů. Existuje také řada online knihoven vzorů regulárních výrazů, jako je například knihovna v Regular-Expressions.info.

Další informace o použití Regex třídy najdete v následujících částech tohoto tématu:

Další informace o jazyce regulárních výrazů najdete v tématu Jazyk regulárních výrazů – stručné reference nebo si stáhněte a vytiskněte některou z těchto brožur:

Stručná referenční příručka ve formátu Wordu (.docx)
Stručná reference ve formátu PDF (.pdf)

Metody regulárního výrazu vs. metody řetězce

Třída System.String obsahuje několik metod vyhledávání a porovnání, které můžete použít k porovnávání vzorů s textem. Metody , String.EndsWitha například určují, String.Containszda instance řetězce obsahuje zadaný podřetězce a String.IndexOfmetody , String.IndexOfAny, String.LastIndexOf, a String.LastIndexOfAny vrátí počáteční pozici zadaného podřetězce v řetězciString.StartsWith. System.String Metody třídy použijte při hledání konkrétního řetězce. Regex Třídu použijte při hledání konkrétního vzoru v řetězci. Další informace a příklady najdete v tématu Regulární výrazy .NET.

Zpět na Poznámky

Statické metody vs. metody instance

Jakmile definujete vzor regulárního výrazu, můžete ho poskytnout modulu regulárních výrazů jedním ze dvou způsobů:

  • Vytvořením instance objektu Regex , který představuje regulární výraz. Chcete-li to provést, předáte vzor regulárního výrazu konstruktoru Regex . Objekt Regex je neměnný. Když vytvoříte instanci objektu Regex s regulárním výrazem, regulární výraz daného objektu nelze změnit.

  • Zadáním regulárního výrazu i textu k vyhledání static metody (Shared v jazyce Visual Basic). Regex To umožňuje použít regulární výraz bez explicitního vytvoření objektu Regex .

Všechny Regex metody identifikace vzorů zahrnují statické i instance přetížení.

Modul regulárních výrazů musí před jeho použití zkompilovat konkrétní vzor. Vzhledem k tomu Regex , že objekty jsou neměnné, jedná se o jednorázovou proceduru, ke které dochází při volání konstruktoru Regex třídy nebo statické metody. Aby se eliminovala nutnost opakovaně kompilovat jeden regulární výraz, modul regulárních výrazů ukládá kompilované regulární výrazy používané při volání statických metod do mezipaměti. V důsledku toho nabízejí metody porovnávání vzorů regulárních výrazů srovnatelný výkon pro statické a instanční metody.

Důležité

V rozhraní .NET Framework verze 1.0 a 1.1 byly všechny kompilované regulární výrazy, ať už byly použity při volání instance nebo statické metody, uloženy do mezipaměti. Počínaje rozhraním .NET Framework 2.0 jsou do mezipaměti uloženy pouze regulární výrazy používané ve volání statických metod.

Ukládání do mezipaměti však může nepříznivě ovlivnit výkon v následujících dvou případech:

  • Při použití statické metody volání s velkým počtem regulárních výrazů. Ve výchozím nastavení modul regulárních výrazů ukládá do mezipaměti 15 naposledy použitých statických regulárních výrazů. Pokud vaše aplikace používá více než 15 statických regulárních výrazů, je nutné některé regulární výrazy znovu zkompilovat. Chcete-li zabránit této rekompilace, můžete zvýšit Regex.CacheSize hodnotu vlastnosti.

  • Když vytvoříte instanci nových Regex objektů s regulárními výrazy, které byly dříve zkompilovány. Například následující kód definuje regulární výraz pro vyhledání duplicitních slov v textovém streamu. I když příklad používá jeden regulární výraz, vytvoří instanci nového Regex objektu pro zpracování každého řádku textu. Výsledkem je rekompilace regulárního výrazu s každou iterací smyčky.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()
    

    Chcete-li zabránit rekompilace, měli byste vytvořit instanci jednoho Regex objektu, který je přístupný pro veškerý kód, který to vyžaduje, jak je znázorněno v následujícím přepisu příkladu.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()
    

Zpět na poznámky

Provádění operací regulárního výrazu

Bez ohledu na to, jestli se rozhodnete vytvořit instanci objektu Regex a volat jeho metody nebo volat statické metody, Regex třída nabízí následující funkce porovnávání vzorů:

  • Ověření shody. Zavoláte metodu IsMatch k určení, zda je k dispozici shoda.

  • Načtení jedné shody Zavoláte metodu Match pro načtení objektu Match , který představuje první shodu v řetězci nebo v části řetězce. Následné shody lze načíst voláním Match.NextMatch metody .

  • Načtení všech shod. Zavoláte metodu Matches pro načtení objektu System.Text.RegularExpressions.MatchCollection , který představuje všechny shody nalezené v řetězci nebo v části řetězce.

  • Nahrazení odpovídajícího textu Zavoláte metodu Replace , která nahradí odpovídající text. Náhradní text může být také definován regulárním výrazem. Kromě toho některé metody Replace obsahují MatchEvaluator parametr, který umožňuje programově definovat nahrazování textu.

  • Vytvoření pole řetězců, které je vytvořeno z částí vstupního řetězce. Voláním Split metody rozdělíte vstupní řetězec na pozice, které jsou definovány regulárním výrazem.

Kromě metod porovnávání vzorů Regex zahrnuje třída několik speciálních metod:

  • Metoda Escape umisí všechny znaky, které mohou být interpretovány jako operátory regulárního výrazu v regulárním výrazu nebo vstupním řetězci.

  • Metoda Unescape tyto řídicí znaky odebere.

  • Metoda CompileToAssembly vytvoří sestavení, které obsahuje předdefinované regulární výrazy. Rozhraní .NET Framework obsahuje příklady těchto sestavení pro zvláštní účely v System.Web.RegularExpressions oboru názvů.

Zpět na poznámky

Definování hodnoty časového limitu

.NET podporuje plnohodnotný jazyk regulárních výrazů, který poskytuje značnou sílu a flexibilitu při porovnávání vzorů. Výkon a flexibilita však stojí za cenu: riziko nízkého výkonu. Regulární výrazy, které fungují špatně, se překvapivě snadno vytvářejí. V některých případech se při zpracování textu, který téměř odpovídá vzoru regulárního výrazu, může zdát, že operace regulárních výrazů, které jsou závislé na nadměrném zpětném navracení, přestanou reagovat. Další informace o modulu regulárních výrazů .NET najdete v tématu Podrobnosti o chování regulárních výrazů. Další informace o nadměrném navracení najdete v tématu Vrácení zpět.

Počínaje rozhraním .NET Framework 4.5 můžete definovat interval časového limitu pro shody regulárních výrazů, abyste omezili nadměrné navracení. V závislosti na vzoru regulárního výrazu a vstupním textu může doba provádění překročit zadaný interval časového limitu, ale nebude trávit více času zpět než zadaný interval časového limitu. Pokud vyprší časový limit modulu regulárních výrazů RegexMatchTimeoutException , vyvolá výjimku. Ve většině případů to brání stroji regulárních výrazů v plýtvání výpočetním výkonem tím, že se snaží shodovat s textem, který téměř odpovídá vzoru regulárního výrazu. Může to také znamenat, že interval časového limitu byl nastaven příliš nízký nebo že aktuální zatížení počítače způsobilo celkové snížení výkonu.

Způsob zpracování výjimky závisí na příčině výjimky. Pokud k výjimce dojde kvůli příliš nízkému intervalu časového limitu nebo kvůli nadměrnému zatížení počítače, můžete časový limit prodloužit a zkusit znovu provést odpovídající operaci. Pokud k výjimce dojde, protože regulární výraz spoléhá na nadměrné navracení, můžete předpokládat, že shoda neexistuje, a volitelně můžete protokolovat informace, které vám pomůžou upravit vzor regulárního výrazu.

Časový limit můžete nastavit voláním konstruktoru Regex(String, RegexOptions, TimeSpan) při vytváření instance objektu regulárního výrazu. U statických metod můžete nastavit interval časového limitu voláním přetížení odpovídající metody, která má matchTimeout parametr. Pokud hodnotu časového limitu nenastavíte explicitně, výchozí hodnota časového limitu se určí takto:

  • Pomocí hodnoty časového limitu pro celou aplikaci, pokud existuje. Může se jednat o libovolnou hodnotu časového limitu, která se vztahuje na doménu aplikace, ve které Regex se vytvoří instance objektu, nebo se provede volání statické metody. Hodnotu časového limitu pro celou aplikaci můžete nastavit voláním AppDomain.SetData metody, která přiřadí řetězcovou TimeSpan reprezentaci hodnoty vlastnosti "REGEX_DEFAULT_MATCH_TIMEOUT".

  • Pomocí hodnoty InfiniteMatchTimeout, pokud nebyla nastavena žádná hodnota časového limitu pro celou aplikaci.

Důležité

Doporučujeme nastavit hodnotu časového limitu ve všech operacích porovnávání vzorů regulárních výrazů. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy.

Zpět na poznámky

Konstruktory

Regex()

Inicializuje novou instanci Regex třídy .

Regex(SerializationInfo, StreamingContext)

Inicializuje novou instanci Regex třídy pomocí serializovaných dat.

Regex(String)

Inicializuje novou instanci Regex třídy pro zadaný regulární výraz.

Regex(String, RegexOptions)

Inicializuje novou instanci Regex třídy pro zadaný regulární výraz s možnostmi, které mění vzor.

Regex(String, RegexOptions, TimeSpan)

Inicializuje novou instanci Regex třídy pro zadaný regulární výraz s možnostmi, které upravují vzor a hodnotu, která určuje, jak dlouho by se měla metoda porovnávání vzorů pokoušet o shodu, než vyprší její časový limit.

Pole

capnames

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

caps

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

capsize

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

capslist

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

factory

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

InfiniteMatchTimeout

Určuje, že by u operace porovnávání vzorů neměl vyprcházet časový limit.

internalMatchTimeout

Maximální doba, která může uplynout při operaci porovnávání vzorů, než vyprší časový limit operace.

pattern

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

roptions

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

Vlastnosti

CacheSize

Získá nebo nastaví maximální počet položek v aktuální statické mezipaměti kompilovaných regulárních výrazů.

CapNames

Získá nebo nastaví slovník, který mapuje pojmenované zachytávání skupin na hodnoty indexu.

Caps

Získá nebo nastaví slovník, který mapuje číslované zachycené skupiny na hodnoty indexu.

MatchTimeout

Získá časový limit interval aktuální instance.

Options

Získá možnosti, které byly předány konstruktoru Regex .

RightToLeft

Získá hodnotu, která označuje, zda regulární výraz hledá zprava doleva.

Metody

CompileToAssembly(RegexCompilationInfo[], AssemblyName)
Zastaralé.

Zkompiluje jeden nebo více zadaných Regex objektů do pojmenovaného sestavení.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])
Zastaralé.

Zkompiluje jeden nebo více zadaných Regex objektů do pojmenovaného sestavení se zadanými atributy.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)
Zastaralé.

Zkompiluje jeden nebo více zadaných Regex objektů a zadaný soubor prostředků do pojmenovaného sestavení se zadanými atributy.

Count(ReadOnlySpan<Char>)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí počet shod.

Count(ReadOnlySpan<Char>, Int32)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí počet shod.

Count(ReadOnlySpan<Char>, String)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí počet shod.

Count(ReadOnlySpan<Char>, String, RegexOptions)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí počet shod.

Count(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí počet shod.

Count(String)

Vyhledá ve vstupním řetězci všechny výskyty regulárního výrazu a vrátí počet shod.

Count(String, String)

Vyhledá ve vstupním řetězci všechny výskyty regulárního výrazu a vrátí počet shod.

Count(String, String, RegexOptions)

Vyhledá ve vstupním řetězci všechny výskyty regulárního výrazu a vrátí počet shod.

Count(String, String, RegexOptions, TimeSpan)

Vyhledá ve vstupním řetězci všechny výskyty regulárního výrazu a vrátí počet shod.

EnumerateMatches(ReadOnlySpan<Char>)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí Regex.ValueMatchEnumerator iteraci po shodách.

EnumerateMatches(ReadOnlySpan<Char>, Int32)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí Regex.ValueMatchEnumerator iteraci po shodách.

EnumerateMatches(ReadOnlySpan<Char>, String)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí Regex.ValueMatchEnumerator iteraci po shodách.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí Regex.ValueMatchEnumerator iteraci po shodách.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Vyhledá vstupní rozsah pro všechny výskyty regulárního výrazu a vrátí Regex.ValueMatchEnumerator iteraci po shodách.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
Escape(String)

Minimální sadu znaků (\, *, +, ?, |, {, [, (,), ^, $, ., #a prázdné znaky uniká řídicími znaky. To dává modulu regulárních výrazů pokyn, aby tyto znaky interpretoval doslovně, a ne jako metaznaky.

Finalize()

Tento člen přepíše Finalize()a v tomto tématu může být k dispozici úplnější dokumentace.

Object Umožňuje pokusit se uvolnit prostředky a provádět další operace čištění před Object uvolněním paměti uvolňováním paměti.

GetGroupNames()

Vrátí pole zachycení názvů skupin pro regulární výraz.

GetGroupNumbers()

Vrátí matici obsahující čísla skupin, která odpovídají názvům skupin v matici.

GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetType()

Type Získá z aktuální instance.

(Zděděno od Object)
GroupNameFromNumber(Int32)

Získá název skupiny, který odpovídá zadanému číslu skupiny.

GroupNumberFromName(String)

Vrátí číslo skupiny, které odpovídá zadanému názvu skupiny.

InitializeReferences()

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

IsMatch(ReadOnlySpan<Char>)

Určuje, zda regulární výraz zadaný v konstruktoru Regex najde shodu v zadaném vstupním rozsahu.

IsMatch(ReadOnlySpan<Char>, Int32)

Určuje, zda regulární výraz zadaný v konstruktoru Regex najde shodu v zadaném vstupním rozsahu.

IsMatch(ReadOnlySpan<Char>, String)

Určuje, jestli zadaný regulární výraz najde shodu v zadaném rozsahu vstupu.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Určuje, jestli zadaný regulární výraz najde shodu v zadaném rozsahu vstupu pomocí zadaných možností shody.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Určuje, jestli zadaný regulární výraz najde shodu v zadaném rozsahu vstupu pomocí zadaných možností shody a intervalu časového limitu.

IsMatch(String)

Určuje, zda regulární výraz zadaný v konstruktoru Regex najde shodu v zadaném vstupním řetězci.

IsMatch(String, Int32)

Určuje, zda regulární výraz zadaný v konstruktoru Regex najde shodu v zadaném vstupním řetězci počínaje zadanou počáteční pozicí v řetězci.

IsMatch(String, String)

Určuje, jestli zadaný regulární výraz najde shodu v zadaném vstupním řetězci.

IsMatch(String, String, RegexOptions)

Určuje, jestli zadaný regulární výraz najde shodu v zadaném vstupním řetězci pomocí zadaných možností shody.

IsMatch(String, String, RegexOptions, TimeSpan)

Určuje, jestli zadaný regulární výraz najde shodu v zadaném vstupním řetězci pomocí zadaných možností shody a intervalu časového limitu.

Match(String)

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

Match(String, Int32)

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

Match(String, Int32, Int32)

Vyhledá ve vstupním řetězci první výskyt regulárního výrazu, počínaje zadanou počáteční pozicí a vyhledáváním pouze zadaného počtu znaků.

Match(String, String)

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

Match(String, String, RegexOptions)

Vyhledá ve vstupním řetězci 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á ve vstupním řetězci první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností a intervalu časového limitu.

Matches(String)

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

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, String)

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

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

MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
Replace(String, MatchEvaluator)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator .

Replace(String, MatchEvaluator, Int32)

V zadaném vstupním řetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, řetězcem vráceným delegátem MatchEvaluator .

Replace(String, MatchEvaluator, Int32, Int32)

V zadaném vstupním podřetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, řetězcem vráceným delegátem MatchEvaluator .

Replace(String, String)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

Replace(String, String, Int32)

V zadaném vstupním řetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

Replace(String, String, Int32, Int32)

V zadaném vstupním podřetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

Replace(String, String, MatchEvaluator)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator .

Replace(String, String, MatchEvaluator, RegexOptions)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator . Zadané možnosti upraví odpovídající operaci.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

V zadaném vstupním řetězci nahradí všechny podřetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator . Další parametry určují možnosti, které upravují odpovídající operaci a časový limit, pokud se nenajde žádná shoda.

Replace(String, String, String)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem.

Replace(String, String, String, RegexOptions)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem. Zadané možnosti upraví odpovídající operaci.

Replace(String, String, String, RegexOptions, TimeSpan)

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem. Další parametry určují možnosti, které upravují odpovídající operaci a časový limit, pokud se nenajde žádná shoda.

Split(String)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných vzorem regulárního výrazu zadaným v konstruktoru Regex .

Split(String, Int32)

Rozdělí vstupní řetězec zadaný maximální početkrát do pole podřetězců na pozicích definovaných regulárním výrazem zadaným v konstruktoru Regex .

Split(String, Int32, Int32)

Rozdělí vstupní řetězec zadaný maximální početkrát do pole podřetězců na pozicích definovaných regulárním výrazem zadaným v konstruktoru Regex . Hledání vzoru regulárního výrazu začíná na zadané pozici znaku ve vstupním řetězci.

Split(String, String)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných vzorem regulárního výrazu.

Split(String, String, RegexOptions)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných zadaným vzorem regulárního výrazu. Zadané možnosti upraví odpovídající operaci.

Split(String, String, RegexOptions, TimeSpan)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných zadaným vzorem regulárního výrazu. Další parametry určují možnosti, které upravují odpovídající operaci a časový limit, pokud se nenajde žádná shoda.

ToString()

Vrátí vzor regulárního výrazu, který byl předán konstruktoru Regex .

Unescape(String)

Převede všechny řídicí znaky ve vstupním řetězci.

UseOptionC()

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

UseOptionR()

Používá se objektem Regex vygenerovaným metodou CompileToAssembly .

ValidateMatchTimeout(TimeSpan)

Zkontroluje, jestli je časový limit v přijatelném rozsahu.

Explicitní implementace rozhraní

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Naplní SerializationInfo objekt daty potřebnými k deserializaci aktuálního Regex objektu.

Platí pro

Bezpečný přístup z více vláken

Třída Regex je neměnná (jen pro čtení) a bezpečná z více vláken. Regex objekty lze vytvořit v libovolném vlákně a sdílet mezi vlákny. Další informace najdete v tématu Zabezpečení vláken.

Viz také