Regex Klasa

Definicja

Przestrzeń nazw:

System.Text.RegularExpressions

Zestaw:

System.Text.RegularExpressions.dll

Reprezentuje niezmienne wyrażenie regularne.

public ref class Regex : System::Runtime::Serialization::ISerializable

public class Regex : System.Runtime.Serialization.ISerializable

type Regex = class
    interface ISerializable

Public Class Regex
Implements ISerializable

Dziedziczenie

Object

Regex

Pochodne

System.Web.RegularExpressions.AspCodeRegex

System.Web.RegularExpressions.AspEncodedExprRegex

System.Web.RegularExpressions.AspExprRegex

System.Web.RegularExpressions.CommentRegex

System.Web.RegularExpressions.DatabindExprRegex

System.Web.RegularExpressions.DataBindRegex

System.Web.RegularExpressions.DirectiveRegex

System.Web.RegularExpressions.EndTagRegex

System.Web.RegularExpressions.GTRegex

System.Web.RegularExpressions.IncludeRegex

System.Web.RegularExpressions.LTRegex

System.Web.RegularExpressions.RunatServerRegex

System.Web.RegularExpressions.ServerTagsRegex

System.Web.RegularExpressions.SimpleDirectiveRegex

System.Web.RegularExpressions.TagRegex

System.Web.RegularExpressions.TagRegex35

System.Web.RegularExpressions.TextRegex

Implementuje

ISerializable

Przykłady

W poniższym przykładzie użyto wyrażenia regularnego do sprawdzania występowania powtarzających się wystąpień wyrazów w ciągu. Wyrażenie \b(?<word>\w+)\s+(\k<word>)\b regularne można interpretować, jak pokazano w poniższej tabeli.

Wzorce	Opis
\b	Rozpocznij dopasowanie na granicy wyrazu.
(?<word>\w+)	Dopasuj co najmniej jeden znak słowa do granicy wyrazu. Nadaj tej przechwyconej grupie wordnazwę .
\s+	Dopasuj co najmniej jeden znak odstępu.
(\k<word>)	Dopasuj przechwyconą grupę o nazwie word.
\b	Dopasowuje granicę wyrazu.

#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

W poniższym przykładzie pokazano użycie wyrażenia regularnego w celu sprawdzenia, czy ciąg reprezentuje wartość waluty, czy ma poprawny format reprezentujący wartość waluty. W tym przypadku wyrażenie regularne jest tworzone dynamicznie na podstawie NumberFormatInfo.CurrencyDecimalSeparatorwłaściwości , CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbolNumberFormatInfo.NegativeSign, i NumberFormatInfo.PositiveSign dla kultury en-US. Wynikowe wyrażenie regularne to ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. To wyrażenie regularne można interpretować, jak pokazano w poniższej tabeli.

Wzorce	Opis
^	Zacznij od początku ciągu.
\s*	Dopasowanie do zera lub większej liczby znaków odstępu.
[\+-]?	Dopasowuje zero lub jedno wystąpienie znaku dodatniego lub znaku ujemnego.
\s?	Dopasowuje zero lub jeden znak odstępu.
\$?	Dopasuj zero lub jedno wystąpienie znaku dolara.
\s?	Dopasowuje zero lub jeden znak odstępu.
\d*	Dopasowanie do zera lub większej liczby cyfr dziesiętnych.
\.?	Dopasuj zero lub jeden symbol separatora dziesiętnego.
(\d{2})?	Przechwytywanie grupy 1: Dopasuj dwie cyfry dziesiętne zero lub jeden raz.
(\d*\.?(\d{2})?){1}	Dopasuj wzorzec cyfr całkowitych i ułamkowych rozdzielonych symbolem separatora dziesiętnego co najmniej raz.
$	Dopasuj koniec ciągu.

W tym przypadku wyrażenie regularne zakłada, że prawidłowy ciąg walutowy nie zawiera symboli separatora grup i że nie zawiera cyfr ułamkowych ani liczby cyfr ułamkowych zdefiniowanych przez właściwość określonej kultury CurrencyDecimalDigits .

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.

Ponieważ wyrażenie regularne w tym przykładzie jest tworzone dynamicznie, nie wiesz w czasie projektowania, czy symbol waluty, znak dziesiętny lub pozytywne i negatywne oznaki określonej kultury (en-US w tym przykładzie) mogą być błędnie interpretowane przez aparat wyrażeń regularnych jako operatory języka wyrażeń regularnych. Aby zapobiec błędnej interpretacji, przykład przekazuje do metody każdy dynamicznie wygenerowany ciąg Escape .

Uwagi

Klasa Regex reprezentuje aparat wyrażeń regularnych .NET Framework. Może służyć do szybkiego analizowania dużych ilości tekstu w celu znalezienia określonych wzorców znaków; wyodrębnianie, edytowanie, zastępowanie lub usuwanie podciągów tekstu; i dodać wyodrębnione ciągi do kolekcji w celu wygenerowania raportu.

Uwaga

Jeśli twoim głównym celem jest zweryfikowanie ciągu, określając, czy jest on zgodny z określonym wzorcem, możesz użyć System.Configuration.RegexStringValidator klasy .

Aby używać wyrażeń regularnych, należy zdefiniować wzorzec, który chcesz zidentyfikować w strumieniu tekstowym, przy użyciu składni udokumentowanej w języku wyrażeń regularnych — krótki przewodnik. Następnie możesz opcjonalnie utworzyć Regex wystąpienie obiektu. Na koniec wywołujesz metodę wykonującą pewną operację, taką jak zastępowanie tekstu zgodnego ze wzorcem wyrażenia regularnego lub identyfikowanie dopasowania wzorca.

Uwaga

Aby zapoznać się z niektórymi typowymi wzorcami wyrażeń regularnych, zobacz Przykłady wyrażeń regularnych. Istnieje również wiele bibliotek online wzorców wyrażeń regularnych, takich jak ta w Regular-Expressions.info.

Aby uzyskać więcej informacji na temat korzystania z Regex klasy, zobacz następujące sekcje w tym temacie:

• Regex vs. Metody ciągów

• Metody statyczne vs. Metody wystąpienia

• Wykonywanie operacji na wyrażeniach regularnych

• Definiowanie wartości limitu czasu

Aby uzyskać więcej informacji na temat języka wyrażeń regularnych, zobacz Język wyrażeń regularnych — krótki przewodnik lub pobierz i wydrukuj jedną z tych broszur:

Krótki przewodnik w formacie Word (.docx)
Krótki przewodnik w formacie PDF (.pdf)

Regex vs. Metody ciągów

Klasa System.String zawiera kilka metod wyszukiwania i porównywania, których można użyć do dopasowywania wzorców z tekstem. Na przykład metody , i określają, String.Containsczy wystąpienie ciągu zawiera określony podciąg, a String.IndexOfmetody , String.IndexOfAny, String.LastIndexOfi String.LastIndexOfAny zwracają pozycję początkową określonego podciągu w String.StartsWith ciągu. String.EndsWith Użyj metod System.String klasy podczas wyszukiwania określonego ciągu. Regex Użyj klasy podczas wyszukiwania określonego wzorca w ciągu. Aby uzyskać więcej informacji i przykłady, zobacz .NET Regular Expressions (Wyrażenia regularne platformy .NET).

Powrót do uwag

Metody statyczne vs. Metody wystąpienia

Po zdefiniowaniu wzorca wyrażenia regularnego można udostępnić go aparatowi wyrażeń regularnych na jeden z dwóch sposobów:

• Tworząc wystąpienie Regex obiektu reprezentującego wyrażenie regularne. W tym celu należy przekazać wzorzec wyrażenia regularnego do konstruktora Regex . Obiekt jest niezmienny. Podczas Regex tworzenia wystąpienia Regex obiektu za pomocą wyrażenia regularnego nie można zmienić wyrażenia regularnego tego obiektu.

• Podając zarówno wyrażenie regularne, jak i tekst do wyszukiwania w metodzie static (Shared w języku Visual Basic). Regex Dzięki temu można używać wyrażenia regularnego bez jawnego Regex tworzenia obiektu.

Wszystkie Regex metody identyfikacji wzorca obejmują zarówno przeciążenia statyczne, jak i wystąpienia.

Aparat wyrażeń regularnych musi skompilować określony wzorzec, zanim będzie można użyć wzorca. Ponieważ Regex obiekty są niezmienne, jest to jednorazowa procedura, która występuje, gdy Regex wywoływany jest konstruktor klasy lub metoda statyczna. Aby wyeliminować konieczność wielokrotnego kompilowania pojedynczego wyrażenia regularnego, aparat wyrażeń regularnych buforuje skompilowane wyrażenia regularne używane w wywołaniach metody statycznej. W rezultacie metody dopasowywania wzorców wyrażeń regularnych oferują porównywalną wydajność dla metod statycznych i wystąpień.

Ważne

W .NET Framework w wersjach 1.0 i 1.1 wszystkie skompilowane wyrażenia regularne, niezależnie od tego, czy były używane w wywołaniach metod statycznych, były buforowane. Począwszy od .NET Framework 2.0, buforowane są tylko wyrażenia regularne używane w wywołaniach metod statycznych.

Jednak buforowanie może mieć negatywny wpływ na wydajność w następujących dwóch przypadkach:

• W przypadku używania wywołań metod statycznych z dużą liczbą wyrażeń regularnych. Domyślnie aparat wyrażeń regularnych buforuje 15 ostatnio używanych statycznych wyrażeń regularnych. Jeśli aplikacja używa więcej niż 15 statycznych wyrażeń regularnych, niektóre wyrażenia regularne muszą zostać ponownie skompilowane. Aby zapobiec ponownej Regex.CacheSize kompilacji, można zwiększyć właściwość .

• Podczas tworzenia wystąpień nowych Regex obiektów za pomocą wyrażeń regularnych, które zostały wcześniej skompilowane. Na przykład poniższy kod definiuje wyrażenie regularne w celu zlokalizowania zduplikowanych wyrazów w strumieniu tekstowym. Mimo że w przykładzie użyto pojedynczego wyrażenia regularnego, tworzy wystąpienie nowego Regex obiektu do przetwarzania każdego wiersza tekstu. Spowoduje to ponowne skompilowanie wyrażenia regularnego z każdą iterację pętli.

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

  Aby zapobiec ponownej kompilacji, należy utworzyć wystąpienie pojedynczego Regex obiektu, który jest dostępny dla całego kodu, który go wymaga, jak pokazano w poniższym przykładzie przepisanym.

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

Powrót do uwag

Wykonywanie operacji na wyrażeniach regularnych

Niezależnie od tego, czy zdecydujesz się utworzyć wystąpienie Regex obiektu i wywołać jego metody, czy wywołać metody statyczne, Regex klasa oferuje następujące funkcje dopasowania wzorca:

• Walidacja dopasowania. Wywołasz metodę , IsMatch aby określić, czy istnieje dopasowanie.

• Pobieranie pojedynczego dopasowania. Metoda jest wywoływana w Match celu pobrania Match obiektu reprezentującego pierwsze dopasowanie w ciągu lub w części ciągu. Kolejne dopasowania można pobrać, wywołując metodę Match.NextMatch .

• Pobieranie wszystkich dopasowań. Metoda jest wywoływana w Matches celu pobrania System.Text.RegularExpressions.MatchCollection obiektu reprezentującego wszystkie dopasowania znalezione w ciągu lub w części ciągu.

• Zamiana dopasowanego tekstu. Wywołasz metodę Replace , aby zastąpić dopasowany tekst. Tekst zastępczy można również zdefiniować za pomocą wyrażenia regularnego. Ponadto niektóre Replace metody obejmują MatchEvaluator parametr, który umożliwia programowe definiowanie tekstu zastępczego.

• Tworzenie tablicy ciągów utworzonej na podstawie części ciągu wejściowego. Metoda jest wywoływana w Split celu podzielenia ciągu wejściowego w pozycjach zdefiniowanych przez wyrażenie regularne.

Oprócz metod dopasowywania wzorców klasa zawiera kilka metod Regex specjalnego przeznaczenia:

• Metoda Escape unika wszystkich znaków, które mogą być interpretowane jako operatory wyrażeń regularnych w wyrażeniu regularnym lub ciągu wejściowym.

• Metoda Unescape usuwa te znaki ucieczki.

• Metoda CompileToAssembly tworzy zestaw zawierający wstępnie zdefiniowane wyrażenia regularne. .NET Framework zawiera przykłady tych zestawów specjalnych w System.Web.RegularExpressions przestrzeni nazw.

Powrót do uwag

Definiowanie wartości limitu czasu

Platforma .NET obsługuje w pełni funkcjonalny język wyrażeń regularnych, który zapewnia znaczną moc i elastyczność dopasowywania wzorców. Jednak moc i elastyczność są kosztem: ryzyko niskiej wydajności. Wyrażenia regularne, które działają słabo, są zaskakująco łatwe do utworzenia. W niektórych przypadkach operacje wyrażeń regularnych, które polegają na nadmiernym wycofywaniu, mogą wydawać się przestać odpowiadać podczas przetwarzania tekstu, który prawie pasuje do wzorca wyrażenia regularnego. Aby uzyskać więcej informacji na temat aparatu wyrażeń regularnych platformy .NET, zobacz Szczegóły zachowania wyrażeń regularnych. Aby uzyskać więcej informacji na temat nadmiernego wycofywania, zobacz Wycofywanie.

Począwszy od .NET Framework 4.5, można zdefiniować interwał limitu czasu dla dopasowań wyrażeń regularnych w celu ograniczenia nadmiernego wycofywania. W zależności od wzorca wyrażenia regularnego i tekstu wejściowego czas wykonywania może przekraczać określony interwał limitu czasu, ale nie spędzi więcej czasu na wycofywanie niż określony interwał limitu czasu. Jeśli aparat wyrażeń regularnych RegexMatchTimeoutException upłynął limit czasu, zgłasza wyjątek. W większości przypadków uniemożliwia to aparatowi wyrażeń regularnych marnowanie mocy obliczeniowej przez próbę dopasowania tekstu, który prawie pasuje do wzorca wyrażenia regularnego. Może to również wskazywać, że interwał przekroczenia limitu czasu został ustawiony zbyt nisko lub że bieżące obciążenie maszyny spowodowało ogólne obniżenie wydajności.

Sposób obsługi wyjątku zależy od przyczyny wyjątku. Jeśli wyjątek występuje, ponieważ interwał przekroczenia limitu czasu jest ustawiony za mało lub z powodu nadmiernego obciążenia maszyny, możesz zwiększyć interwał limitu czasu i ponowić próbę wykonania zgodnej operacji. Jeśli wyjątek występuje, ponieważ wyrażenie regularne opiera się na nadmiernym wycofywaniu, można założyć, że dopasowanie nie istnieje, a opcjonalnie możesz rejestrować informacje, które pomogą ci zmodyfikować wzorzec wyrażenia regularnego.

Interwał limitu czasu można ustawić, wywołując konstruktor podczas Regex(String, RegexOptions, TimeSpan) tworzenia wystąpienia obiektu wyrażenia regularnego. W przypadku metod statycznych można ustawić interwał przekroczenia limitu czasu przez wywołanie przeciążenia pasującej metody, która ma matchTimeout parametr. Jeśli jawnie nie ustawisz wartości limitu czasu, domyślna wartość limitu czasu jest określana w następujący sposób:

• Używając wartości limitu czasu dla całej aplikacji, jeśli istnieje. Może to być dowolna wartość limitu czasu, która ma zastosowanie do domeny aplikacji, w której Regex jest tworzone wystąpienie obiektu lub jest wykonywane wywołanie metody statycznej. Możesz ustawić wartość limitu czasu dla całej aplikacji, wywołując AppDomain.SetData metodę w celu przypisania reprezentacji TimeSpan ciągu wartości do właściwości "REGEX_DEFAULT_MATCH_TIMEOUT".

• Używając wartości InfiniteMatchTimeout, jeśli nie ustawiono wartości limitu czasu dla całej aplikacji.

Ważne

Zalecamy ustawienie wartości limitu czasu we wszystkich operacjach dopasowywania wzorców wyrażeń regularnych. Aby uzyskać więcej informacji, zobacz Najlepsze rozwiązania dotyczące wyrażeń regularnych.

Powrót do uwag

Konstruktory

Regex()	Inicjuje nowe wystąpienie klasy Regex.
Regex(SerializationInfo, StreamingContext)	Nieaktualne. Inicjuje Regex nowe wystąpienie klasy przy użyciu danych serializowanych.
Regex(String)	Inicjuje Regex nowe wystąpienie klasy dla określonego wyrażenia regularnego.
Regex(String, RegexOptions)	Inicjuje Regex nowe wystąpienie klasy dla określonego wyrażenia regularnego z opcjami, które modyfikują wzorzec.
Regex(String, RegexOptions, TimeSpan)	Inicjuje nowe wystąpienie Regex klasy dla określonego wyrażenia regularnego z opcjami modyfikującymi wzorzec i wartością określającą, jak długo metoda dopasowania wzorca powinna podjąć próbę dopasowania przed upływem limitu czasu.

Pola

capnames	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
caps	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
capsize	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
capslist	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
factory	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
InfiniteMatchTimeout	Określa, że operacja dopasowania wzorca nie powinna upłynął limit czasu.
internalMatchTimeout	Maksymalny czas, który może upłynąć w operacji dopasowania wzorca przed przekroczeniem limitu czasu operacji.
pattern	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
roptions	Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .

Właściwości

CacheSize	Pobiera lub ustawia maksymalną liczbę wpisów w bieżącej statycznej pamięci podręcznej skompilowanych wyrażeń regularnych.
CapNames	Pobiera lub ustawia słownik, który mapuje nazwy przechwytywania grup na ich wartości indeksu.
Caps	Pobiera lub ustawia słownik, który mapuje numerowane grupy przechwytywania na ich wartości indeksu.
MatchTimeout	Pobiera interwał limitu czasu bieżącego wystąpienia.
Options	Pobiera opcje, które zostały przekazane do konstruktora Regex .
RightToLeft	Pobiera wartość wskazującą, czy wyrażenie regularne wyszukuje się od prawej do lewej.

Metody

CompileToAssembly(RegexCompilationInfo[], AssemblyName)	Nieaktualne. Kompiluje co najmniej jeden określony Regex obiekt do nazwanego zestawu.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])	Nieaktualne. Kompiluje co najmniej jeden określony Regex obiekt do nazwanego zestawu z określonymi atrybutami.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)	Nieaktualne. Kompiluje co najmniej jeden określony Regex obiekt i określony plik zasobów do nazwanego zestawu z określonymi atrybutami.
Count(ReadOnlySpan<Char>)	Wyszukuje zakres wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(ReadOnlySpan<Char>, Int32)	Wyszukuje zakres wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(ReadOnlySpan<Char>, String)	Wyszukuje zakres wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(ReadOnlySpan<Char>, String, RegexOptions)	Wyszukuje zakres wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)	Wyszukuje zakres wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(String)	Wyszukuje ciąg wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(String, String)	Wyszukuje ciąg wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(String, String, RegexOptions)	Wyszukuje ciąg wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
Count(String, String, RegexOptions, TimeSpan)	Wyszukuje ciąg wejściowy dla wszystkich wystąpień wyrażenia regularnego i zwraca liczbę dopasowań.
EnumerateMatches(ReadOnlySpan<Char>)	Wyszukuje zakres danych wejściowych dla wszystkich wystąpień wyrażenia regularnego i zwraca wartość Regex.ValueMatchEnumerator , aby iterować dopasowania.
EnumerateMatches(ReadOnlySpan<Char>, Int32)	Wyszukuje zakres danych wejściowych dla wszystkich wystąpień wyrażenia regularnego i zwraca wartość Regex.ValueMatchEnumerator , aby iterować dopasowania.
EnumerateMatches(ReadOnlySpan<Char>, String)	Wyszukuje zakres danych wejściowych dla wszystkich wystąpień wyrażenia regularnego i zwraca wartość Regex.ValueMatchEnumerator , aby iterować dopasowania.
EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)	Wyszukuje zakres danych wejściowych dla wszystkich wystąpień wyrażenia regularnego i zwraca wartość Regex.ValueMatchEnumerator , aby iterować dopasowania.
EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)	Wyszukuje zakres danych wejściowych dla wszystkich wystąpień wyrażenia regularnego i zwraca wartość Regex.ValueMatchEnumerator , aby iterować dopasowania.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
Escape(String)	Usuwa minimalny zestaw znaków (\, *, +, ?, |, {, [, (,), ^, $, ., #i biały odstęp), zastępując je kodami ucieczki. Spowoduje to, że aparat wyrażeń regularnych zinterpretuje te znaki dosłownie, a nie jako metacharactery.
GetGroupNames()	Zwraca tablicę przechwytywania nazw grup dla wyrażenia regularnego.
GetGroupNumbers()	Zwraca tablicę przechwytujących numery grup, które odpowiadają nazwam grup w tablicy.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
GroupNameFromNumber(Int32)	Pobiera nazwę grupy odpowiadającą określonej liczbie grup.
GroupNumberFromName(String)	Zwraca liczbę grup odpowiadającą określonej nazwie grupy.
InitializeReferences()	Nieaktualne. Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
IsMatch(ReadOnlySpan<Char>)	Wskazuje, czy wyrażenie regularne określone w konstruktorze Regex znajduje dopasowanie w określonym zakresie wejściowym.
IsMatch(ReadOnlySpan<Char>, Int32)	Wskazuje, czy wyrażenie regularne określone w konstruktorze Regex znajduje dopasowanie w określonym zakresie wejściowym.
IsMatch(ReadOnlySpan<Char>, String)	Wskazuje, czy określone wyrażenie regularne znajduje dopasowanie w określonym zakresie wejściowym.
IsMatch(ReadOnlySpan<Char>, String, RegexOptions)	Wskazuje, czy określone wyrażenie regularne znajduje dopasowanie w określonym zakresie wejściowym przy użyciu określonych opcji dopasowania.
IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)	Wskazuje, czy określone wyrażenie regularne znajduje dopasowanie w określonym zakresie wejściowym przy użyciu określonych opcji dopasowania i interwału limitu czasu.
IsMatch(String)	Wskazuje, czy wyrażenie regularne określone w konstruktorze Regex znajduje dopasowanie w określonym ciągu wejściowym.
IsMatch(String, Int32)	Wskazuje, czy wyrażenie regularne określone w konstruktorze Regex znajduje dopasowanie w określonym ciągu wejściowym, zaczynając od określonej pozycji początkowej w ciągu.
IsMatch(String, String)	Wskazuje, czy określone wyrażenie regularne znajduje dopasowanie w określonym ciągu wejściowym.
IsMatch(String, String, RegexOptions)	Wskazuje, czy określone wyrażenie regularne znajduje dopasowanie w określonym ciągu wejściowym przy użyciu określonych opcji dopasowania.
IsMatch(String, String, RegexOptions, TimeSpan)	Wskazuje, czy określone wyrażenie regularne znajduje dopasowanie w określonym ciągu wejściowym przy użyciu określonych opcji dopasowania i interwału przekroczenia limitu czasu.
Match(String)	Wyszukuje określony ciąg wejściowy dla pierwszego wystąpienia wyrażenia regularnego określonego w konstruktorze Regex .
Match(String, Int32)	Wyszukuje ciąg wejściowy pierwszego wystąpienia wyrażenia regularnego, zaczynając od określonej pozycji początkowej w ciągu.
Match(String, Int32, Int32)	Wyszukuje ciąg wejściowy pierwszego wystąpienia wyrażenia regularnego, zaczynając od określonej pozycji początkowej i wyszukując tylko określoną liczbę znaków.
Match(String, String)	Wyszukuje określony ciąg wejściowy dla pierwszego wystąpienia określonego wyrażenia regularnego.
Match(String, String, RegexOptions)	Wyszukuje ciąg wejściowy pierwszego wystąpienia określonego wyrażenia regularnego przy użyciu określonych opcji dopasowania.
Match(String, String, RegexOptions, TimeSpan)	Wyszukuje ciąg wejściowy dla pierwszego wystąpienia określonego wyrażenia regularnego przy użyciu określonych opcji dopasowania i interwału przekroczenia limitu czasu.
Matches(String)	Wyszukuje określony ciąg wejściowy dla wszystkich wystąpień wyrażenia regularnego.
Matches(String, Int32)	Wyszukuje określony ciąg wejściowy dla wszystkich wystąpień wyrażenia regularnego, zaczynając od określonej pozycji początkowej w ciągu.
Matches(String, String)	Wyszukuje określony ciąg wejściowy dla wszystkich wystąpień określonego wyrażenia regularnego.
Matches(String, String, RegexOptions)	Wyszukuje określony ciąg wejściowy dla wszystkich wystąpień określonego wyrażenia regularnego przy użyciu określonych opcji dopasowania.
Matches(String, String, RegexOptions, TimeSpan)	Wyszukuje określony ciąg wejściowy dla wszystkich wystąpień określonego wyrażenia regularnego przy użyciu określonych opcji dopasowania i interwału limitu czasu.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Replace(String, MatchEvaluator)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, MatchEvaluator, Int32)	W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, MatchEvaluator, Int32, Int32)	W określonym podciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, String)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne ze wzorcem wyrażenia regularnego określonym ciągiem zastępczym.
Replace(String, String, Int32)	W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego określonym ciągiem zastępczym.
Replace(String, String, Int32, Int32)	W określonym podciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego określonym ciągiem zastępczym.
Replace(String, String, MatchEvaluator)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, String, MatchEvaluator, RegexOptions)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym ciągiem zwracanym przez delegata MatchEvaluator . Określone opcje modyfikują odpowiednią operację.
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)	W określonym ciągu wejściowym zastępuje wszystkie podciągy zgodne z określonym wyrażeniem regularnym ciągiem zwróconym przez delegata MatchEvaluator . Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.
Replace(String, String, String)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym.
Replace(String, String, String, RegexOptions)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym. Określone opcje modyfikują odpowiednią operację.
Replace(String, String, String, RegexOptions, TimeSpan)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym. Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.
Split(String)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego określonego w konstruktorze Regex .
Split(String, Int32)	Dzieli ciąg wejściowy określoną maksymalną liczbę razy na tablicę podciągów w pozycjach zdefiniowanych przez wyrażenie regularne określone w konstruktorze Regex .
Split(String, Int32, Int32)	Dzieli ciąg wejściowy określoną maksymalną liczbę razy na tablicę podciągów w pozycjach zdefiniowanych przez wyrażenie regularne określone w konstruktorze Regex . Wyszukiwanie wzorca wyrażenia regularnego rozpoczyna się od określonej pozycji znaku w ciągu wejściowym.
Split(String, String)	Dzieli ciąg wejściowy na tablicę podciągów na pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego.
Split(String, String, RegexOptions)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Określone opcje modyfikują zgodną operację.
Split(String, String, RegexOptions, TimeSpan)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.
ToString()	Zwraca wzorzec wyrażenia regularnego, który został przekazany do konstruktora Regex .
Unescape(String)	Konwertuje wszystkie znaki ucieczki w ciągu wejściowym.
UseOptionC()	Nieaktualne. Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
UseOptionR()	Nieaktualne. Używany przez Regex obiekt wygenerowany przez metodę CompileToAssembly .
ValidateMatchTimeout(TimeSpan)	Sprawdza, czy interwał limitu czasu mieści się w akceptowalnym zakresie.

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

SerializationInfo Wypełnia obiekt danymi niezbędnymi do deserializacji bieżącego Regex obiektu.

Bezpieczeństwo wątkowe

Klasa Regex jest niezmienna (tylko do odczytu) i bezpieczna wątkowo. Regex obiekty można tworzyć w dowolnym wątku i udostępniać między wątkami. Aby uzyskać więcej informacji, zobacz Bezpieczeństwo wątków.

Zobacz też

• RegexStringValidator
• Wyrażenia regularne platformy .NET
• Elementy języka wyrażeń regularnych
• Wyrażenia regularne — szybka dokumentacja (pobieranie w formacie Word)
• Wyrażenia regularne — szybka dokumentacja (pobieranie w formacie PDF)