Regex Regex Regex Regex Class

Definicja

Reprezentuje niezmienne wyrażenie regularne.Represents an immutable regular expression.

public ref class Regex : System::Runtime::Serialization::ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
    interface ISerializable
Public Class Regex
Implements ISerializable
Dziedziczenie
RegexRegexRegexRegex
Pochodne
Atrybuty
Implementuje

Przykłady

W poniższym przykładzie użyto wyrażenia regularnego, aby sprawdzić, czy są powtarzane wystąpień słowa w ciągu.The following example uses a regular expression to check for repeated occurrences of words in a string. Wyrażenie regularne \b(?<word>\w+)\s+(\k<word>)\b mogą być interpretowane, jak pokazano w poniższej tabeli.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczęcie dopasowywania na granicy wyrazu.Start the match at a word boundary.
(?<word>\w+) Dopasowuje co najmniej jeden znak słowa do granicy wyrazu.Match one or more word characters up to a word boundary. Nazwij tę przechwyconą grupę word.Name this captured group word.
\s+ Dopasowuje co najmniej jeden znak odstępu.Match one or more white-space characters.
(\k<word>) Pasuje do przechwyconej grupy, który nosi nazwę word.Match the captured group that is named word.
\b Dopasowuje granicę wyrazu.Match a word boundary.
#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 50 and 54
Imports System
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 50 and 54

Poniższy przykład ilustruje użycie wyrażenia regularnego, aby sprawdzić, czy ciąg reprezentuje wartość waluty lub ma poprawny format do reprezentowania wartości waluty.The following example illustrates the use of a regular expression to check whether a string either represents a currency value or has the correct format to represent a currency value. W tym przypadku wyrażenia regularnego jest tworzony dynamicznie z NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, i NumberFormatInfo.PositiveSign właściwości dla bieżącej kultury użytkownika.In this case, the regular expression is built dynamically from the NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, and NumberFormatInfo.PositiveSign properties for the user's current culture. Jeśli bieżący system kulturą jest en US, wynikowe wyrażenie regularne jest ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Mogą być interpretowane tego wyrażenia regularnego, jak pokazano w poniższej tabeli.This regular expression can be interpreted as shown in the following table.

WzorzecPattern OpisDescription
^ Rozpocznij od początku ciągu.Start at the beginning of the string.
\s* Dopasowanie do zera lub większej liczby znaków odstępu.Match zero or more white-space characters.
[\+-]? Dopasowanie zera lub jednego wystąpienia znaku dodatniego lub znaku minus.Match zero or one occurrence of either the positive sign or the negative sign.
\s? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
\$? Dopasowuje znak dolara zera lub jednego wystąpienia.Match zero or one occurrence of the dollar sign.
\s? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
\d* Dopasowanie do zera lub większej liczby cyfr dziesiętnych.Match zero or more decimal digits.
\.? Dopasowuje zero lub jeden symbol separatora dziesiętnego.Match zero or one decimal point symbol.
\d{2}? Dopasowuje dwie cyfry dziesiętne zero lub jeden raz.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Dopasowuje wzorzec zaokrągleń cyfry oddzielone symbol dziesiętny co najmniej jeden raz.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Dopasowuje koniec ciągu.Match the end of the string.

W tym przypadku wyrażenia regularnego zakłada waluty prawidłowy ciąg nie zawiera symbole separatorów grup i że ma nie cyfr ułamkowych, jaka lub liczba cyfr ułamkowych, zdefiniowane przez bieżącą kulturę CurrencyDecimalDigits właściwości.In this case, the regular expression assumes that a valid currency string does not contain group separator symbols, and that it has either no fractional digits or the number of fractional digits defined by the current culture's CurrencyDecimalDigits property.

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.

Ponieważ wyrażenia regularnego, w tym przykładzie jest tworzona dynamicznie, firma Microsoft nie jest znany w czasie projektowania czy symbol waluty bieżącej kultury, znaku dziesiętnego lub znaków pozytywnych i negatywnych może zostać błędnie zinterpretowane przez aparat wyrażeń regularnych jako regularne Operatory języka wyrażeń.Because the regular expression in this example is built dynamically, we do not know at design time whether the current culture's currency symbol, decimal sign, or positive and negative signs might be misinterpreted by the regular expression engine as regular expression language operators. Aby zapobiec błędnej, przykład przekazuje każdego dynamicznie generowanym ciąg Escape metody.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Uwagi

Regex Klasa reprezentuje aparat wyrażeń regularnych programu .NET Framework.The Regex class represents the .NET Framework's regular expression engine. Może służyć do szybkiego analizowania dużych ilości tekstu, aby znaleźć wzory znaków specyficznych; Aby wyodrębnić, Edytuj, zastępowania lub usuwania podciągów tekstu; i dodawać wyodrębnione ciągi do kolekcji, aby wygenerować raport.It can be used to quickly parse large amounts of text to find specific character patterns; to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection to generate a report.

Uwaga

W przypadku zainteresowanie podstawowego do sprawdzania ciągu przy określaniu, czy jest zgodny z określonym wzorcem, można użyć System.Configuration.RegexStringValidator klasy.If your primary interest is to validate a string by determining whether it conforms to a particular pattern, you can use the System.Configuration.RegexStringValidator class.

Aby użyć wyrażeń regularnych, należy zdefiniować wzorzec, który chcesz zidentyfikować w strumieniu tekstu przy użyciu składni udokumentowane w artykule język wyrażeń regularnych — podręczny wykaz.To use regular expressions, you define the pattern that you want to identify in a text stream by using the syntax documented in Regular Expression Language - Quick Reference. Następnie można opcjonalnie utworzyć wystąpienie Regex obiektu.Next, you can optionally instantiate a Regex object. Na koniec należy wywołać metodę, która wykonuje pewne operacje, takie jak zastępowanie tekstu, który pasuje do wzorca wyrażenia regularnego lub identyfikowanie dopasowania do wzorca.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

Uwaga

Aby uzyskać niektóre typowe wzorce wyrażeń regularnych, zobacz przykłady wyrażeń regularnych.For some common regular expression patterns, see Regular Expression Examples. Dostępne są także szereg online biblioteki wzorców wyrażeń regularnych, takiego jak w Expressions.info zwykłych.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Aby uzyskać więcej informacji o używaniu Regex klasy, zobacz następujące sekcje w tym temacie:For more information about using the Regex class, see the following sections in this topic:

Aby uzyskać więcej informacji na temat języka wyrażeń regularnych, zobacz język wyrażeń regularnych — podręczny wykaz lub pobrać i wydrukować jedną z tych broszury:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Krótki przewodnik w formacie programu Word (.docx)Quick Reference in Word (.docx) format
Krótki przewodnik w formacie PDF (PDF)Quick Reference in PDF (.pdf) format

Wyrażenie regularne programu vs. Parametry metodyRegex vs. String Methods

System.String Klasa zawiera kilka wyszukiwania i porównanie metod, których można użyć do wykonania dopasowania z tekstem do wzorca.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Na przykład String.Contains, String.EndsWith, i String.StartsWith metody ustalić, czy wystąpienie ciągu zawiera określony podciąg; i String.IndexOf, String.IndexOfAny, String.LastIndexOf, i String.LastIndexOfAny metody zwracają początkowy Pozycja określony podciąg w ciągu.For example, the String.Contains, String.EndsWith, and String.StartsWith methods determine whether a string instance contains a specified substring; and the String.IndexOf, String.IndexOfAny, String.LastIndexOf, and String.LastIndexOfAny methods return the starting position of a specified substring in a string. Należy użyć metod System.String klasy podczas wyszukiwania określonego ciągu.Use the methods of the System.String class when you are searching for a specific string. Użyj Regex klasy podczas wyszukiwania określonego wzorca w ciągu.Use the Regex class when you are searching for a specific pattern in a string. Aby uzyskać więcej informacji i przykładów, zobacz wyrażeń regularnych programu .NET Framework.For more information and examples, see .NET Framework Regular Expressions.

Powrót do uwagiBack to Remarks

Statycznej. Metody wystąpieniaStatic vs. Instance Methods

Po zdefiniowaniu wzorzec wyrażenia regularnego, można zapewnić aparat wyrażeń regularnych w jeden z dwóch sposobów:After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Przez utworzenie wystąpienia Regex obiekt, który reprezentuje wyrażenie regularne.By instantiating a Regex object that represents the regular expression. W tym celu należy przekazać wzorzec wyrażenia regularnego do Regex konstruktora.To do this, you pass the regular expression pattern to a Regex constructor. A Regex obiekt jest niezmienialny; podczas tworzenia wystąpienia Regex obiektu z wyrażeniem regularnym, że nie można zmienić obiektu wyrażenia regularnego.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Podając wyrażeń regularnych i tekst do wyszukania do static (Shared w języku Visual Basic) Regex metody.By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Dzięki temu można użyć wyrażenia regularnego, bez konieczności jawnego tworzenia Regex obiektu.This enables you to use a regular expression without explicitly creating a Regex object.

Wszystkie Regex metod identyfikacji wzorca obejmują statycznych i wystąpienia przeciążenia.All Regex pattern identification methods include both static and instance overloads.

Aparat wyrażeń regularnych, należy skompilować wzorcowi, przed użyciem wzorca.The regular expression engine must compile a particular pattern before the pattern can be used. Ponieważ Regex obiekty są niezmienne, jest to jednorazowa procedury, która występuje podczas Regex konstruktora klasy lub metody statycznej jest wywoływana.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. Aby wyeliminować konieczność wielokrotnego skompilować pojedynczego wyrażenia regularnego, aparat wyrażeń regularnych buforuje skompilowane wyrażenia regularne użyte w wywołaniach metody statycznej.To eliminate the need to repeatedly compile a single regular expression, the regular expression engine caches the compiled regular expressions used in static method calls. W rezultacie metod dopasowania do wzorca wyrażenia regularnego oferują porównywalne wydajność statyczne i metody wystąpień.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Ważne

W .NET Framework w wersji 1.0 i 1.1, wszystkich skompilowanych wyrażeń regularnych czy zostały użyte w wystąpieniu lub statycznej metody wywołania, były buforowane.In the .NET Framework versions 1.0 and 1.1, all compiled regular expressions, whether they were used in instance or static method calls, were cached. Począwszy od programu .NET Framework 2.0, tylko wyrażenia regularne użyte w wywołaniach metody statycznej są buforowane.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

Jednakże buforowanie może niekorzystnie wpłynąć na wydajność w dwóch przypadkach:However, caching can adversely affect performance in the following two cases:

  • Kiedy używasz wywołaniach metody statycznej z dużą liczbą wyrażeń regularnych.When you use static method calls with a large number of regular expressions. Domyślnie aparat wyrażenia regularnego buforuje 15 ostatnio używanych statycznych wyrażeń regularnych.By default, the regular expression engine caches the 15 most recently used static regular expressions. Jeśli aplikacja korzysta z więcej niż 15 statycznych wyrażeń regularnych, niektóre wyrażenia regularnego należy kompilować podczas.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. Aby zapobiec ponownej kompilacji na tym, można zwiększyć Regex.CacheSize właściwości.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Podczas tworzenia wystąpienia nowego Regex obiektów za pomocą wyrażeń regularnych, które wcześniej zostały skompilowane.When you instantiate new Regex objects with regular expressions that have previously been compiled. Na przykład poniższy kod definiuje wyrażenie regularne, aby zlokalizować zduplikowanych słów w strumieniu tekstu.For example, the following code defines a regular expression to locate duplicated words in a text stream. Chociaż w przykładzie użyto pojedynczego wyrażenia regularnego, tworzy nową Regex obiekt, aby przetworzyć każdy wiersz tekstu.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Skutkuje to ponownej kompilacji wyrażeń regularnych, z każdą iteracją pętli.This results in the recompilation of the regular expression with each iteration of the loop.

    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 jednego Regex obiekt, który jest dostępny dla całego kodu, który wymaga, jak pokazano w poniższym przykładzie nowych.To prevent recompilation, you should instantiate a single Regex object that is accessible to all code that requires it, as shown in the following rewritten example.

    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 uwagiBack to Remarks

Wykonywanie operacji na wyrażeniach regularnychPerforming Regular Expression Operations

Czy podjęta została decyzja do utworzenia wystąpienia Regex obiektu i wywołać jego metody lub wywołania metody statyczne, Regex klasy oferują następujące funkcje, dopasowanie wzorca:Whether you decide to instantiate a Regex object and call its methods or call static methods, the Regex class offers the following pattern-matching functionality:

  • Sprawdzanie poprawności dopasowania.Validation of a match. Należy wywołać IsMatch metodę pozwala ustalić, czy dopasowanie jest obecny.You call the IsMatch method to determine whether a match is present.

  • Pobieranie pojedynczego dopasowania.Retrieval of a single match. Należy wywołać Match metodę, która pobierze Match obiekt, który reprezentuje pierwsze dopasowanie w ciągu lub w części ciągu.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. Kolejne dopasowania mogą być pobierane przez wywołanie metody Match.NextMatch metody.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Pobieranie wszystkie dopasowania.Retrieval of all matches. Należy wywołać Matches metodę, która pobierze System.Text.RegularExpressions.MatchCollection obiekt, który reprezentuje wszystkie dopasowania w ciągu lub w części ciągu.You call the Matches method to retrieve a System.Text.RegularExpressions.MatchCollection object that represents all the matches found in a string or in part of a string.

  • Zastąpienie dopasowany tekst.Replacement of matched text. Należy wywołać Replace metodę, aby zastąpić dopasowany tekst.You call the Replace method to replace matched text. Tekst zastępczy można zdefiniować w taki sposób, przez wyrażenia regularne.The replacement text can also be defined by a regular expression. Ponadto niektóre Replace metody obejmują MatchEvaluator parametr, który umożliwia programowane Definiowanie tekst zastępczy.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Tworzenie tablica ciągu, który jest tworzony na podstawie części ciągu wejściowego.Creation of a string array that is formed from parts of an input string. Należy wywołać Split metodę, aby podzielić ciąg wejściowy w pozycjach, które są zdefiniowane przez wyrażenia regularne.You call the Split method to split an input string at positions that are defined by the regular expression.

Oprócz jego metod dopasowania do wzorca Regex klasy zawiera kilka metod specjalnego przeznaczenia:In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • Escape Metoda zmienia znaczenie znaków, które mogą być interpretowane jako operatory wyrażeń regularnych, wyrażenia regularnego lub ciągu wejściowego.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • Unescape Metoda usuwa te znaki ucieczki.The Unescape method removes these escape characters.

  • CompileToAssembly Metoda tworzy zestaw, który zawiera wstępnie zdefiniowanych wyrażeń regularnych.The CompileToAssembly method creates an assembly that contains predefined regular expressions. .NET Framework zawiera przykłady tych zestawów specjalnych w System.Web.RegularExpressions przestrzeni nazw.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Powrót do uwagiBack to Remarks

Definiowanie wartości limitu czasuDefining a Time-Out Value

.NET Framework obsługuje język wyrażeń regularnych w pełni funkcjonalne, który zapewnia znaczące możliwości i elastyczność w dopasowywania do wzorca.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. Jednak możliwości i elastyczność pochodzą kosztów: ryzyka pogorszenia wydajności.However, the power and flexibility come at a cost: the risk of poor performance. Wyrażenia regularne, które niskiej wydajności są zaskakująco można łatwo utworzyć.Regular expressions that perform poorly are surprisingly easy to create. W niektórych przypadkach operacji na wyrażeniach regularnych, które zależą od nadmierne używanie wycofywania może znajdować się może przestać odpowiadać podczas przetwarzania tekstu, który prawie pasuje do wzorca wyrażenia regularnego.In some cases, regular expression operations that rely on excessive backtracking can appear to stop responding when they process text that nearly matches the regular expression pattern. Aby uzyskać więcej informacji na temat aparatu wyrażeń regularnych systemu .NET Framework, zobacz szczegóły zachowania wyrażeń regularnych.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Aby uzyskać więcej informacji na temat nadmiernego wycofywania, zobacz Backtracking.For more information about excessive backtracking, see Backtracking.

Począwszy od .NET Framework 4.5.NET Framework 4.5, można zdefiniować interwał limitu czasu wyrażenia regularnego dopasowania.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. Jeśli aparat wyrażeń regularnych nie może zidentyfikować dopasowania, w tym przedziale czasu, zgłasza operacji dopasowywania RegexMatchTimeoutException wyjątku.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. W większości przypadków uniemożliwia to aparatowi wyrażeń regularnych marnowania mocy obliczeniowej, próbując dopasować tekst, który prawie pasuje do wzorca wyrażenia regularnego.In most cases, this prevents the regular expression engine from wasting processing power by trying to match text that nearly matches the regular expression pattern. Również może wskazywać, jednak, że interwał limitu czasu ustawiono zbyt mała lub czy bieżące obciążenie maszyny spowodowała spadku ogólnej wydajności.It also could indicate, however, that the timeout interval has been set too low, or that the current machine load has caused an overall degradation in performance.

Jak obsłużyć wyjątek, zależy od przyczyną wyjątku.How you handle the exception depends on the cause of the exception. Jeśli wystąpi wyjątek, ponieważ interwał limitu czasu jest ustawiony na zbyt niską lub ze względu na maszynie nadmiernego obciążenia, możesz zwiększyć interwał limitu czasu i ponów próbę wykonania operacji dopasowywania.If the exception occurs because the time-out interval is set too low or because of excessive machine load, you can increase the time-out interval and retry the matching operation. Jeśli wystąpi wyjątek, ponieważ wyrażenie regularne opiera się na nadmierne używanie wycofywania, możesz założono, że dopasowanie nie istnieje i ewentualnie możesz rejestrować informacje, które pomogą Ci modyfikować wzorzec wyrażenia regularnego.If the exception occurs because the regular expression relies on excessive backtracking, you can assume that a match does not exist, and, optionally, you can log information that will help you modify the regular expression pattern.

Możesz ustawić interwał limitu czasu, przez wywołanie metody Regex(String, RegexOptions, TimeSpan) Konstruktor podczas tworzenia wystąpienia obiektu wyrażenia regularnego.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. Dla metod statycznych, można ustawić interwał limitu czasu przez wywołanie przeciążenia metody dopasowania, który ma matchTimeout parametru.For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. Jeśli nie jawnie ustawiona wartość limitu czasu, domyślną wartość limitu czasu jest określany w następujący sposób:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • Przy użyciu limitu czasu całej aplikacji wartości, jeśli taki istnieje.By using the application-wide time-out value, if one exists. To może być dowolną wartością limitu czasu, która ma zastosowanie do domeny aplikacji, w którym Regex jest tworzone wystąpienie obiektu lub wykonywane wywołanie metody statycznej.This can be any time-out value that applies to the application domain in which the Regex object is instantiated or the static method call is made. Można ustawić wartość limitu czasu w całej aplikacji, wywołując AppDomain.SetData metodę, aby przypisać reprezentację ciągu TimeSpan wartość właściwości "REGEX_DEFAULT_MATCH_TIMEOUT".You can set the application-wide time-out value by calling the AppDomain.SetData method to assign the string representation of a TimeSpan value to the "REGEX_DEFAULT_MATCH_TIMEOUT" property.

  • Przy użyciu wartości InfiniteMatchTimeout, jeśli została ustawiona żadna wartość limitu czasu w całej aplikacji.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Ważne

Firma Microsoft zaleca, ustaw wartość limitu czasu we wszystkich operacjach dopasowania do wzorca wyrażenia regularnego.We recommend that you set a time-out value in all regular expression pattern-matching operations. Aby uzyskać więcej informacji, zobacz najlepsze rozwiązania dotyczące wyrażeń regularnych.For more information, see Best Practices for Regular Expressions.

Powrót do uwagiBack to Remarks

Konstruktory

Regex() Regex() Regex() Regex()

Inicjuje nowe wystąpienie klasy Regex klasy.Initializes a new instance of the Regex class.

Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext)

Inicjuje nowe wystąpienie klasy Regex przy użyciu danych serializowanych na fragmenty.Initializes a new instance of the Regex class by using serialized data.

Regex(String) Regex(String) Regex(String) Regex(String)

Inicjuje nowe wystąpienie klasy Regex klasy dla określonego wyrażenia regularnego.Initializes a new instance of the Regex class for the specified regular expression.

Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions)

Inicjuje nowe wystąpienie klasy Regex klasy dla określonego wyrażenia regularnego z opcjami, które modyfikują wzorzec.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan)

Inicjuje nowe wystąpienie klasy Regex klasy dla określonego wyrażenia regularnego z opcjami, które modyfikują wzorzec i wartość, która określa, jak długo metody dopasowania do wzorca powinien podejmować próbę dopasowania, przed upływem limitu czasu.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

Pola

capnames capnames capnames capnames

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

caps caps caps caps

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

capsize capsize capsize capsize

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

capslist capslist capslist capslist

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

factory factory factory factory

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout

Określa, że to operacja dopasowania do wzorca powinien nie przekraczają limit czasu.Specifies that a pattern-matching operation should not time out.

internalMatchTimeout internalMatchTimeout internalMatchTimeout internalMatchTimeout

Limit czasu maksymalną ilość czasu, jaki może upłynąć dopasowania do wzorca operacji przed wykonaniem operacji.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern pattern pattern pattern

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

roptions roptions roptions roptions

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

Właściwości

CacheSize CacheSize CacheSize CacheSize

Pobiera lub ustawia maksymalną liczbę wpisów w bieżącym statycznej pamięci podręcznej skompilowanych wyrażeń regularnych.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames CapNames CapNames CapNames

Pobiera lub ustawia słownik mapujący nazwanych grup przechwytywania, ich wartości indeksu.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps Caps Caps Caps

Pobiera lub ustawia słownik mapujący numerowanych grup przechwytywania, ich wartości indeksu.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout MatchTimeout MatchTimeout MatchTimeout

Pobiera interwał limitu czasu bieżącego wystąpienia.Gets the time-out interval of the current instance.

Options Options Options Options

Pobiera opcje, które zostały przekazane do Regex konstruktora.Gets the options that were passed into the Regex constructor.

RightToLeft RightToLeft RightToLeft RightToLeft

Pobiera wartość wskazującą, czy wyrażenia regularnego przeszukuje od prawej do lewej.Gets a value that indicates whether the regular expression searches from right to left.

Metody

CompileToAssembly(RegexCompilationInfo[], AssemblyName) CompileToAssembly(RegexCompilationInfo[], AssemblyName) CompileToAssembly(RegexCompilationInfo[], AssemblyName) CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Kompiluje co najmniej jeden określony Regex obiektów w zestawie o nazwie.Compiles one or more specified Regex objects to a named assembly.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Kompiluje co najmniej jeden określony Regex obiekty do nazwanych zestawów przy użyciu określonych atrybutów.Compiles one or more specified Regex objects to a named assembly with the specified attributes.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Kompiluje co najmniej jeden określony Regex obiektów i plik określony zasób do nazwanego zestawu przy użyciu określonych atrybutów.Compiles one or more specified Regex objects and a specified resource file to a named assembly with the specified attributes.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Escape(String) Escape(String) Escape(String) Escape(String)

Minimalny zbiór znaki specjalne (\, *, +,?, |, {, [, (,), ^, $,., # i biały znak) przez zamianę ich kodów wyjścia.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. To powoduje, że aparat wyrażeń regularnych do interpretacji tych znaków, dosłownie, a nie jako metaznaki.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

Finalize() Finalize() Finalize() Finalize()

Ten element członkowski przesłania element Finalize(), a dokładniejsza dokumentacja może być dostępna w tym temacie.This member overrides Finalize(), and more complete documentation might be available in that topic.

Umożliwia Object próby zwolnienie zasobów i wykonywać inne operacje oczyszczania przed Object jest odzyskiwane przez wyrzucanie elementów bezużytecznych.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

GetGroupNames() GetGroupNames() GetGroupNames() GetGroupNames()

Zwraca tablicę nazw grup dla wyrażenia regularnego przechwytywania.Returns an array of capturing group names for the regular expression.

GetGroupNumbers() GetGroupNumbers() GetGroupNumbers() GetGroupNumbers()

Zwraca tablicę przechwytywania numery grupy, które odpowiadają nazwom grupy w tablicy.Returns an array of capturing group numbers that correspond to group names in an array.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Służy jako domyślnej funkcji skrótu.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Inherited from Object)
GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) GroupNameFromNumber(Int32)

Pobiera nazwę grupy, która odpowiada numerowi określonej grupy.Gets the group name that corresponds to the specified group number.

GroupNumberFromName(String) GroupNumberFromName(String) GroupNumberFromName(String) GroupNumberFromName(String)

Zwraca numer grupy, która odnosi się do nazwy określonej grupy.Returns the group number that corresponds to the specified group name.

InitializeReferences() InitializeReferences() InitializeReferences() InitializeReferences()

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

IsMatch(String) IsMatch(String) IsMatch(String) IsMatch(String)

Wskazuje, czy wyrażenie regularne określony w Regex Konstruktor znalezienia dopasowania określonego ciągu wejściowego.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

IsMatch(String, Int32) IsMatch(String, Int32) IsMatch(String, Int32) IsMatch(String, Int32)

Wskazuje, czy wyrażenie regularne określony w Regex Konstruktor znalezienia dopasowania w określonym ciągu wejściowym, zaczynając od określonej pozycji początkowej w ciągu.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String) IsMatch(String, String) IsMatch(String, String) IsMatch(String, String)

Wskazuje, czy określonemu wyrażeniu regularnemu znalezienia dopasowania do określonego ciągu wejściowego.Indicates whether the specified regular expression finds a match in the specified input string.

IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions)

Wskazuje, czy określonemu wyrażeniu regularnemu znalezienia dopasowania w określonym ciągu wejściowym, przy użyciu określonych opcji dopasowania.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan)

Wskazuje, czy określonemu wyrażeniu regularnemu znalezienia dopasowania w określonym ciągu wejściowym, przy użyciu określonego dopasowania interwał opcje i limitu czasu.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

Match(String) Match(String) Match(String) Match(String)

Wyszukuje określony ciągu wejściowym, aby pierwsze wystąpienie z wyrażeniem regularnym określonym w Regex konstruktora.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, Int32) Match(String, Int32) Match(String, Int32) Match(String, Int32)

Wyszukuje w ciągu wejściowym, aby pierwsze wystąpienie wyrażenia regularnego, zaczynając od określonej pozycji początkowej w ciągu.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32)

Wyszukuje w ciągu wejściowym, aby pierwsze wystąpienie wyrażenia regularnego, zaczynając od określonej pozycji początkowej i wyszukiwanie tylko określoną liczbę znaków.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String) Match(String, String) Match(String, String) Match(String, String)

Wyszukuje określony ciągu wejściowym, aby pierwsze wystąpienie określonego wyrażenia regularnego.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions)

Wyszukuje w ciągu wejściowym, aby pierwsze wystąpienie określonego wyrażenia regularnego przy użyciu określonych opcji dopasowania.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan)

Wyszukuje w ciągu wejściowym, aby pierwsze wystąpienie określonego wyrażenia regularnego przy użyciu określonego dopasowania interwał opcje i limitu czasu.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Matches(String) Matches(String) Matches(String) Matches(String)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia wyrażeń regularnych.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32) Matches(String, Int32) Matches(String, Int32) Matches(String, Int32)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia wyrażeń regularnych, zaczynając od określonej pozycji początkowej w ciągu.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String) Matches(String, String) Matches(String, String) Matches(String, String)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego.Searches the specified input string for all occurrences of a specified regular expression.

Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego, przy użyciu określonych opcji dopasowania.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan)

Wyszukuje określony ciągu wejściowym, aby wszystkie wystąpienia określonego wyrażenia regularnego, przy użyciu określonego dopasowania interwał opcje i limitu czasu.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy płytką kopię bieżącego Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator)

W określonym ciągu wejściowym, zastępuje wszystkie ciągi, które pasują do podanego wyrażenia regularnego z ciągiem, który został zwrócony przez MatchEvaluator delegować.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32)

W określonym ciągu wejściowym, zastępuje określoną maksymalną liczbę ciągów, które pasują do wzorca wyrażenia regularnego z ciągiem, który został zwrócony przez MatchEvaluator delegować.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32)

W podanym podciągiem danych wejściowych, zastępuje określoną maksymalną liczbę ciągów, które pasują do wzorca wyrażenia regularnego z ciągiem, który został zwrócony przez MatchEvaluator delegować.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

W określonym ciągu wejściowym zastępuje wszystkie ciągi, które pasują do wzorca wyrażenia regularnego przy użyciu określony ciąg zastępczy.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32)

W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów, które pasują do wzorca wyrażenia regularnego przy użyciu określony ciąg zastępczy.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32)

W podanym podciągiem danych wejściowych zastępuje określoną maksymalną liczbę ciągów, które pasują do wzorca wyrażenia regularnego przy użyciu określony ciąg zastępczy.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator)

W określonym ciągu wejściowym, zastępuje wszystkie ciągi, które pasują do podanego wyrażenia regularnego z ciągiem, który został zwrócony przez MatchEvaluator delegować.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

W określonym ciągu wejściowym, zastępuje wszystkie ciągi, które pasują do podanego wyrażenia regularnego z ciągiem, który został zwrócony przez MatchEvaluator delegować.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Określone opcje modyfikować operacji dopasowywania.Specified options modify the matching operation.

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

W określonym ciągu wejściowym, zastępuje wszystkie podciągi, które pasują do podanego wyrażenia regularnego z ciągiem, który został zwrócony przez MatchEvaluator delegować.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Dodatkowe parametry, określ opcje modyfikujące operacji dopasowywania i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, String, String) Replace(String, String, String) Replace(String, String, String) Replace(String, String, String)

W określonym ciągu wejściowym zastępuje wszystkie ciągi, które pasują do określonego wyrażenia regularnego z ciągiem określonym zastąpienie.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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

W określonym ciągu wejściowym zastępuje wszystkie ciągi, które pasują do określonego wyrażenia regularnego z ciągiem określonym zastąpienie.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Określone opcje modyfikować operacji dopasowywania.Specified options modify the matching operation.

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

W określonym ciągu wejściowym zastępuje wszystkie ciągi, które pasują do określonego wyrażenia regularnego z ciągiem określonym zastąpienie.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Dodatkowe parametry, określ opcje modyfikujące operacji dopasowywania i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String) Split(String) Split(String) Split(String)

Dzieli ciąg wejściowy na tabelę podciągów w pozycjach zdefiniowane przez wzorzec wyrażenia regularnego określone w Regex konstruktora.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, Int32) Split(String, Int32) Split(String, Int32) Split(String, Int32)

Ciąg wejściowy dzieli dane określoną maksymalną liczbę razy do tablicy podciągów w pozycjach definicją wyrażeniem regularnym określonym w Regex konstruktora.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32)

Ciąg wejściowy dzieli dane określoną maksymalną liczbę razy do tablicy podciągów w pozycjach definicją wyrażeniem regularnym określonym w Regex konstruktora.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. Wyszukiwanie wzorca wyrażenia regularnego rozpoczyna się od określonej pozycji znaku w ciągu wejściowym.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, String) Split(String, String) Split(String, String) Split(String, String)

Dzieli ciąg wejściowy na tabelę podciągów w pozycjach zdefiniowane przez wzorzec wyrażenia regularnego.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions)

Dzieli ciąg wejściowy na tabelę podciągów w pozycjach zdefiniowane przez wzorzec określonemu wyrażeniu regularnemu.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Określone opcje modyfikować operacji dopasowywania.Specified options modify the matching operation.

Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan)

Dzieli ciąg wejściowy na tabelę podciągów w pozycjach zdefiniowane przez wzorzec określonemu wyrażeniu regularnemu.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Dodatkowe parametry, określ opcje modyfikujące operacji dopasowywania i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

ToString() ToString() ToString() ToString()

Zwraca wzorzec wyrażenia regularnego, która została przekazana do Regex konstruktora.Returns the regular expression pattern that was passed into the Regex constructor.

Unescape(String) Unescape(String) Unescape(String) Unescape(String)

Konwertuje wszystkie znaki o zmienionym znaczeniu w ciągu wejściowym.Converts any escaped characters in the input string.

UseOptionC() UseOptionC() UseOptionC() UseOptionC()

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

UseOptionR() UseOptionR() UseOptionR() UseOptionR()

Używane przez Regex generowane przez obiekt CompileToAssembly metody.Used by a Regex object generated by the CompileToAssembly method.

ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan)

Sprawdza, czy interwał limitu czasu znajduje się w dopuszczalnym zakresie.Checks whether a time-out interval is within an acceptable range.

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Wypełnia SerializationInfo obiektu z danymi, które są niezbędne do deserializacji bieżącego Regex obiektu.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

Dotyczy

Bezpieczeństwo wątkowe

Regex Klasy jest niezmienny (tylko do odczytu) i bezpieczne dla wątków.The Regex class is immutable (read-only) and thread safe. Regex obiekty można tworzyć na żadnym z wątków i udostępniane między wątkami.Regex objects can be created on any thread and shared between threads. Aby uzyskać więcej informacji, zobacz bezpieczeństwa wątków.For more information, see Thread Safety.

Zobacz też