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, jak je znázorněno v následující tabulce.

Vzor Description
\b Zahajte shodu na hranici slova.
(?<word>\w+) Porovná jeden nebo více znaků slova až do hranice slova. Pojmenujte tuto zachycenou skupinu word.
\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 znázorňuje použití regulárního výrazu ke kontrole, zda řetězec představuje hodnotu měny nebo má správný formát pro reprezentaci hodnoty měny. V tomto případě se regulární výraz sestavuje dynamicky z NumberFormatInfo.CurrencyDecimalSeparatoraktuální jazykové verze uživatele , CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSigna NumberFormatInfo.PositiveSign vlastnosti. Pokud je aktuální jazyková verze systému en-US, výsledný regulární výraz je ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Tento regulární výraz lze interpretovat, jak je znázorněno v následující tabulce.

Vzor Description
^ Začněte na začátku řetězce.
\s* Porovná žádný nebo více prázdných znaků.
[\+-]? Porovná nulu nebo jeden výskyt kladného znaménka nebo záporného znaménka.
\s? Porovná žádný nebo jeden prázdný znak.
\$? Porovná nulu 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}? Porovná dvě desetinné číslice s nulou nebo jednou.
(\d*\.?\d{2}?){1} Porovná vzor integrálních a zlomkových číslic oddělených desetinnou čárkou alespoň jednou.
$ 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 neobsahuje desetinné číslice nebo počet desetinných číslic definovaných vlastností aktuální jazykové verze CurrencyDecimalDigits .

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

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // 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}$";
      
      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("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -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 = NumberFormatInfo.CurrentInfo

      ' 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}$"
      
      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:
'       -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 dynamicky sestavený, nevíme v době návrhu, zda je symbol měny aktuální jazykové verze, desetinná čárka nebo kladné a záporné znaménka nesprávně interpretován modulem regulárních výrazů jako operátory jazyka regulárních výrazů. Aby se zabránilo nesprávné interpretaci, předá příklad každému dynamicky generovanému řetězci metodě Escape .

Poznámky

Třída Regex představuje modul regulárních výrazů rozhraní .NET Framework. Dá se použít k rychlé analýze velkých objemů textu k vyhledání konkrétních vzorů znaků; k extrakci, úpravám, nahrazení nebo odstranění podřetěžků textu; a přidání extrahovaných řetězců do kolekce za účelem vygenerování sestavy

Poznámka

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

Chcete-li použít regulární výrazy, definujete vzor, který chcete identifikovat v textovém streamu pomocí syntaxe popsané v jazyce regulárních výrazů – rychlá reference. Dále můžete volitelně vytvořit instanci objektu Regex . Nakonec zavoláte metodu, která provádí nějakou 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 v Regular-Expressions.info.

Další informace o používání 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á referenční dokumentace nebo stažení a tisk jedné z těchto brožur:

Rychlý přehled 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 provedení porovnávání vzorů s textem. Například , String.Containsa String.EndsWithString.StartsWith metody určují, zda instance řetězce obsahuje zadaný podřetězec; a String.IndexOf, String.IndexOfAny, String.LastIndexOfa String.LastIndexOfAny metody vrátí počáteční pozici zadaného podřetězce v řetězci. Při hledání konkrétního System.String řetězce použijte metody třídy. Regex Tuto 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í instance objektu Regex , který představuje regulární výraz. Uděláte to tak, že 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, nelze regulární výraz objektu změnit.

  • Zadáním regulárního výrazu i textu, který se má prohledávat metodou static (Sharedv 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 použití vzoru zkompilovat konkrétní vzor. Vzhledem k tomu Regex , že objekty jsou neměnné, jedná se o jednorázový postup, který nastane, když Regex je volána konstruktor třídy nebo statická metoda. Aby bylo možné eliminovat potřebu opakovaného kompilace jednoho regulárního výrazu, modul regulárních výrazů ukládá kompilované regulární výrazy použité ve voláních statických metod. V důsledku toho metody porovnávání vzorů regulárních výrazů nabízejí srovnatelný výkon pro statické a instance 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 v instancích nebo ve volání statické metody, uloženy v mezipaměti. Počínaje rozhraním .NET Framework 2.0 se ukládají do mezipaměti pouze regulární výrazy používané ve volání statické metody.

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

  • Pokud používáte volání statických metod s velkým počtem regulárních výrazů. Modul regulárních výrazů standardně 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ů, musí být některé regulární výrazy překompilovány. Chcete-li zabránit této rekompilace, můžete vlastnost zvětšit Regex.CacheSize .

  • 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, který vyhledá duplicitní slova 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ý ho vyžaduje, jak je znázorněno v následujícím přepsaném 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 její 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 , která určí, jestli je k dispozici shoda.

  • Načtení jedné shody Zavoláte metodu Match Match pro načtení objektu, 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 System.Text.RegularExpressions.MatchCollection pro načtení objektu, 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 lze také definovat regulárním výrazem. Některé metody Replace navíc zahrnují MatchEvaluator parametr, který umožňuje programově definovat náhradní text.

  • Vytvoření řetězcového pole, které je tvořeno částmi vstupního řetězce. Zavoláte metodu rozdělení vstupního Split řetězce 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 uchycuje všechny znaky, které lze interpretovat jako operátory regulárních výrazů v regulárním výrazu nebo vstupním řetězci.

  • Metoda Unescape odebere tyto řídicí znaky.

  • Metoda CompileToAssembly vytvoří sestavení, které obsahuje předdefinované regulární výrazy. Rozhraní .NET Framework obsahuje příklady těchto speciálních sestavení v System.Web.RegularExpressions oboru názvů.

Zpět na poznámky

Definování hodnoty časového limitu

.NET podporuje plně doporučený 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í: riziko nízkého výkonu. Regulární výrazy, které fungují špatně, jsou překvapivě snadno vytvořené. V některých případech se operace regulárních výrazů, které spoléhají na nadměrné zpětné sledování, můžou zdát, že přestanou reagovat, když zpracovávají text, který téměř odpovídá vzoru regulárního výrazu. 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 Zpětné sledování.

Počínaje rozhraním .NET Framework 4.5 můžete definovat interval časového limitu pro regulární výraz, který omezuje 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 vracet zpět než zadaný interval časového limitu. Pokud modul regulárních výrazů vyprší, vyvolá RegexMatchTimeoutException výjimku. Ve většině případů to brání stroji regulárních výrazů ve zpracování výkonu tím, že se pokusí shodovat s textem, který téměř odpovídá vzoru regulárního výrazu. Může to ale také znamenat, že časový limit 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 dojde k výjimce, protože interval časového limitu je nastavený příliš nízký nebo kvůli nadměrnému zatížení počítače, můžete interval časového limitu prodloužit a zopakovat odpovídající operaci. Pokud dojde k výjimce, 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 vytvoření instance objektu regulárního výrazu. U statických metod můžete nastavit časový limit voláním přetížení odpovídající metody, která má matchTimeout parametr. Pokud explicitně nenastavíte hodnotu časového limitu, výchozí hodnota časového limitu se určí takto:

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

  • Pokud nebyla nastavena žádná hodnota InfiniteMatchTimeoutč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é upravují 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ů pokusit o shodu, než vyprší časový limit.

Pole

capnames

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

caps

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

capsize

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

capslist

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

factory

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

InfiniteMatchTimeout

Určuje, že operace porovnávání vzorů by neměla mít časový limit.

internalMatchTimeout

Maximální doba, která může uplyne v operaci porovnávání vzorů před vypršením časového limitu operace.

pattern

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

roptions

Používá objekt Regex vygenerovaný 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 jejich indexové hodnoty.

Caps

Získá nebo nastaví slovník, který mapuje číslovaný zachytávání skupin na jejich indexové hodnoty.

MatchTimeout

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

Options

Získá možnosti, které byly předány do 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ředku 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>, 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á vstupní řetězec pro všechny výskyty regulárního výrazu a vrátí počet shod.

Count(String, String)

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

Count(String, String, RegexOptions)

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

Count(String, String, RegexOptions, TimeSpan)

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

Equals(Object)

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

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

Uvozí minimální sadu znaků (\*, +, ?, |, {, [, (,), ^, $, ., #a prázdné znaky) tak, že je nahradíte jejich řídicími kódy. To dává modulu regulárních výrazů pokyn, aby tyto znaky interpretoval doslova a ne jako metacharactery.

Finalize()

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

Umožňuje pokus o Object uvolnění prostředků a provádění dalších operací čištění před Object uvolněním paměti.

GetGroupNames()

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

GetGroupNumbers()

Vrátí matici zachytávání čísel skupin, které odpovídají názvům skupin v matici.

GetHashCode()

Slouží jako výchozí funkce hash.

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

Type Získá aktuální instanci.

(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á objekt Regex vygenerovaný metodou CompileToAssembly .

IsMatch(ReadOnlySpan<Char>)

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

IsMatch(ReadOnlySpan<Char>, String)

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

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

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

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 Regex konstruktoru najde shodu v zadaném vstupním řetězci.

IsMatch(String, Int32)

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

IsMatch(String, String)

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

IsMatch(String, String, RegexOptions)

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

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á 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 začínající na zadané počáteční pozici v řetězci.

Match(String, Int32, Int32)

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

Match(String, String)

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

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.

Matches(String)

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

Matches(String, Int32)

Vyhledá zadaný vstupní řetězec pro všechny výskyty regulárního výrazu začínající na zadané počáteční pozici v řetězci.

Matches(String, String)

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

Matches(String, String, RegexOptions)

Vyhledá zadaný vstupní řetězec pro 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á zadaný vstupní řetězec pro 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ří použádnou kopii aktuálního souboru Object.

(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 s ř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 se 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 upravují 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 interval časového limitu, 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 upravují odpovídající operaci.

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

V zadaném vstupním řetězci nahradí všechny řetězce odpovídající 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 interval časového limitu, 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ého v konstruktoru Regex .

Split(String, Int32)

Rozdělí vstupní řetězec zadanou maximální dobu 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 zadanou maximální dobu 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 upravují 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 interval časového limitu, pokud se nenajde žádná shoda.

ToString()

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

Unescape(String)

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

UseOptionC()

Používá objekt Regex vygenerovaný metodou CompileToAssembly .

UseOptionR()

Používá objekt Regex vygenerovaný 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é vlákno. Regex Objekty lze vytvořit na libovolném vlákně a sdílet je mezi vlákny. Další informace najdete v tématu Zabezpečení vlákna.

Viz také