Regex Regex Regex Regex Class

Определение

Представляет постоянное регулярное выражение.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
Наследование
RegexRegexRegexRegex
Производный
Атрибуты
Реализации

Примеры

В следующем примере регулярное выражение для проверки для повторяющихся вхождений слов в строке.The following example uses a regular expression to check for repeated occurrences of words in a string. Регулярное выражение \b(?<word>\w+)\s+(\k<word>)\b может интерпретироваться, как показано в следующей таблице.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

ШаблонPattern ОписаниеDescription
\b Начало соответствия на границе слова.Start the match at a word boundary.
(?<word>\w+) Сопоставляется один или несколько словообразующих символов до границы слова.Match one or more word characters up to a word boundary. Имя данной захватываемой группой word.Name this captured group word.
\s+ Совпадение один или несколько символов пробела.Match one or more white-space characters.
(\k<word>) Соответствует группе записи, которая называется word.Match the captured group that is named word.
\b Соответствует границе слова.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

Следующий пример иллюстрирует использование регулярного выражения для проверки ли строка представляет значение валюты или имеет правильный формат для представления значения валюты.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. В этом случае регулярное выражение строится динамически на основе NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, и NumberFormatInfo.PositiveSign свойства для текущего языка и региональных параметров пользователя.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. Если текущий язык и региональные параметры en US, полученный регулярное выражение – ^\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}$. Это регулярное выражение может интерпретироваться, как показано в следующей таблице.This regular expression can be interpreted as shown in the following table.

ШаблонPattern ОписаниеDescription
^ Начать с начала строки.Start at the beginning of the string.
\s* Соответствует нулю или нескольким символам пробела.Match zero or more white-space characters.
[\+-]? Совпадение с нулем или одним вхождением знак плюс или минус.Match zero or one occurrence of either the positive sign or the negative sign.
\s? Совпадение с нулем или одним символом пробела.Match zero or one white-space character.
\$? Совпадение с нулем или одним вхождением знак доллара.Match zero or one occurrence of the dollar sign.
\s? Совпадение с нулем или одним символом пробела.Match zero or one white-space character.
\d* Соответствует нулю или нескольким десятичным числам.Match zero or more decimal digits.
\.? Соответствует ноль или один символ десятичной запятой.Match zero or one decimal point symbol.
\d{2}? Сопоставить две десятичные цифры ноль или один раз.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Совпадение с шаблоном целой и дробной части, разделенные запятой хотя бы один раз.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Поиск конца строки.Match the end of the string.

Таким образом, регулярное выражение предполагает, что строка допустимой валюты не содержит символы разделителя группы, и что он имеет дробных разрядов или количество цифр дробной части определяется текущего языка и региональных параметров CurrencyDecimalDigits свойство.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.

Так как регулярное выражение в этом примере создается динамически, мы не знаем во время разработки ли символ валюты для текущего языка и региональных параметров, десятичного разделителя или положительный и отрицательный знаки могут быть неправильно, обработчик регулярных выражений, как обычный операторы выражений языка.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. Во избежание любой интерпретации в примере передается каждой динамически создаваемые строки Escape метод.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Комментарии

Regex Класс представляет механизм регулярных выражений платформы .NET Framework.The Regex class represents the .NET Framework's regular expression engine. Его можно использовать для быстрого разбора большого текста для поиска определенных шаблонов символов; для извлечения, изменять, заменять или удалять текстовые подстроки, и добавлять извлеченные строки в коллекцию для создания отчета.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.

Примечание

Если ваш основной интерес для проверки строки, определяя их соответствие определенному шаблону, можно использовать System.Configuration.RegexStringValidator класса.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.

Использовать регулярные выражения, можно определить шаблон, который вы хотите определить в текстовый поток, используя синтаксис, задокументированный в языка регулярных выражений — краткий справочник.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. Затем при необходимости можно создать экземпляр Regex объекта.Next, you can optionally instantiate a Regex object. Наконец можно вызвать метод, который выполняет некоторые операции, такие как замена текста, который соответствует шаблону регулярного выражения или идентификация совпадения с шаблоном.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

Примечание

Некоторые распространенные шаблоны регулярных выражений см. в разделе Примеры регулярных выражений.For some common regular expression patterns, see Regular Expression Examples. Также имеется несколько библиотек online шаблоны регулярных выражений, как в Regular Expressions.info.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Дополнительные сведения об использовании Regex класса, в следующих разделах этой статьи:For more information about using the Regex class, see the following sections in this topic:

Дополнительные сведения о языке регулярных выражений см. в кратком справочнике по элементам языка регулярных выражений или в одной из следующих брошюр, который вы можете скачать и распечатать:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Краткий справочник в формате Word (DOCX);Quick Reference in Word (.docx) format
Краткий справочник в формате PDF (PDF).Quick Reference in PDF (.pdf) format

Vs регулярное выражение. Методы строкRegex vs. String Methods

System.String Класс содержит несколько методов поиска и сравнения, которые можно использовать для выполнения сопоставления с текстом шаблона.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Например String.Contains, String.EndsWith, и String.StartsWith методы определяют, содержит ли экземпляр строки заданной подстроки; и String.IndexOf, String.IndexOfAny, String.LastIndexOf, и String.LastIndexOfAny методы возвращают начальный позиции указанной подстроки в строке.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. Используйте методы класса System.String класса при поиске конкретной строки.Use the methods of the System.String class when you are searching for a specific string. Используйте Regex класса при поиске определенного шаблона в строке.Use the Regex class when you are searching for a specific pattern in a string. Дополнительные сведения и примеры см. в разделе регулярные выражения .NET Framework.For more information and examples, see .NET Framework Regular Expressions.

К "Примечания"Back to Remarks

Статические vs. Методы экземпляраStatic vs. Instance Methods

Определив шаблон регулярного выражения, его можно было предоставить к обработчику регулярных выражений одним из двух способов:After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Путем создания экземпляра Regex , представляющий регулярное выражение.By instantiating a Regex object that represents the regular expression. Для этого необходимо передать шаблон регулярного выражения для Regex конструктор.To do this, you pass the regular expression pattern to a Regex constructor. Объект Regex является неизменяемым; при создании экземпляра Regex объекта с регулярным выражением, что регулярное выражение объекта нельзя изменить.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Указав регулярное выражение и текст для поиска для static (Shared в Visual Basic) Regex метод.By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Это позволяет использовать регулярное выражение без явного создания Regex объекта.This enables you to use a regular expression without explicitly creating a Regex object.

Все Regex методы идентификации шаблона включают как статическим и экземпляр перегрузки.All Regex pattern identification methods include both static and instance overloads.

Обработчик регулярных выражений необходимо скомпилировать определенный шаблон, прежде чем можно будет использовать шаблон.The regular expression engine must compile a particular pattern before the pattern can be used. Так как Regex объекты являются неизменяемыми, это одноразовую процедуру, которая возникает, когда Regex вызывается конструктор класса или статический метод.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. Чтобы избежать необходимости повторно компилировать одним регулярным выражением, обработчик регулярных выражений кэширует скомпилированные регулярные выражения, используемые в вызовах статичных методов.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. Таким образом методы поиска совпадения с шаблоном регулярного выражения обеспечивают сравнимую производительность для статических методов и методов экземпляра.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Важно!

В версии 1.0 и 1.1, все скомпилированные регулярные выражения .NET Framework используются ли они в экземпляра или статического метода вызывает, были кэшированы.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. Начиная с .NET Framework 2.0, кэшируются только регулярные выражения, используемые в вызовах статичных методов.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

Тем не менее кэширование может отрицательно сказаться на производительности в следующих двух случаях:However, caching can adversely affect performance in the following two cases:

  • При использовании вызовов статических методов с большим числом регулярные выражения.When you use static method calls with a large number of regular expressions. По умолчанию обработчик регулярных выражений кэширует 15 последних использованных статических регулярных выражений.By default, the regular expression engine caches the 15 most recently used static regular expressions. Если приложение использует более чем 15 статических регулярных выражений, некоторые регулярные выражения должны быть перекомпилированы.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. Чтобы перекомпиляция, вы можете увеличить Regex.CacheSize свойство.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • При создании экземпляра new Regex объектов с помощью регулярных выражений, которые ранее были скомпилированы.When you instantiate new Regex objects with regular expressions that have previously been compiled. Например следующий код определяет регулярное выражение для поиска повторяющихся слов в текстовый поток.For example, the following code defines a regular expression to locate duplicated words in a text stream. Несмотря на то, что в примере используется одним регулярным выражением, он создает новый экземпляр Regex объекта для обработки каждой строки текста.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Это приводит к повторной компиляции регулярного выражения с каждой итерацией цикла.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()   
    

    Чтобы избежать перекомпиляции, следует создавать экземпляр одного Regex объекта, доступного на весь код, которому он требуется, как показано в следующем примере переопределенный.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()   
    

К "Примечания"Back to Remarks

Выполнение операций регулярного выраженияPerforming Regular Expression Operations

От вашего решения для создания экземпляра Regex объекта и вызова его методов или вызывают статические методы Regex класс предлагает следующие функциональные возможности поиска совпадения с шаблоном: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:

  • Проверка соответствия.Validation of a match. Вы вызываете IsMatch метод, чтобы определить, присутствует ли совпадение.You call the IsMatch method to determine whether a match is present.

  • Извлечение одного совпадения.Retrieval of a single match. Вы вызываете Match метод для извлечения Match объект, представляющий первое соответствие в строку, или часть строки.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. Последующие соответствия можно получить, вызвав Match.NextMatch метод.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Извлечение всех совпадений.Retrieval of all matches. Вы вызываете Matches метод для извлечения System.Text.RegularExpressions.MatchCollection , представляющий всеми соответствиями, найденными в строку, или часть строки.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.

  • Замена совпадающего текста.Replacement of matched text. Вы вызываете Replace метод для замены совпадающего текста.You call the Replace method to replace matched text. Текст замены можно также определить регулярным выражением.The replacement text can also be defined by a regular expression. Кроме того, некоторые из Replace методы включают в себя MatchEvaluator параметр, который позволяет программно определить текст замены.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Создание массива строк, сформированный на основе части во входной строке.Creation of a string array that is formed from parts of an input string. Вы вызываете Split способ разделения входную строку в позициях, определенных регулярным выражением.You call the Split method to split an input string at positions that are defined by the regular expression.

В дополнение к его методов поиска совпадения с шаблоном Regex класс включает несколько специализированных методов:In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • Escape Метод экранирует все символы, которые могут быть интерпретированы как операторы регулярных выражений в регулярное выражение или входной строки.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • Unescape Метод удаляет эти escape-символы.The Unescape method removes these escape characters.

  • CompileToAssembly Метод создает сборку, содержащую предварительно определенных регулярных выражений.The CompileToAssembly method creates an assembly that contains predefined regular expressions. .NET Framework содержит примеры эти сборки специального назначения в System.Web.RegularExpressions пространства имен.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

К "Примечания"Back to Remarks

Определение значения времени ожиданияDefining a Time-Out Value

.NET Framework поддерживает язык полнофункциональный регулярного выражения, предоставляет значительные возможности и гибкость при сопоставлении шаблонов.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. Тем не менее, возможности и гибкость некоторых затрат: риск снижения производительности.However, the power and flexibility come at a cost: the risk of poor performance. Регулярные выражения, которые плохо представляют удивительно легко создать.Regular expressions that perform poorly are surprisingly easy to create. В некоторых случаях операции регулярного выражения, которые зависят от избыточный поиск с возвратом может показаться перестать отвечать на запросы при обработке текст, почти соответствующий шаблону регулярного выражения.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. Дополнительные сведения о обработчик регулярных выражений .NET Framework, см. в разделе сведения о поведении регулярных выражений.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Дополнительные сведения о избыточный поиск с возвратом см. в разделе возвратом в регулярных выражениях.For more information about excessive backtracking, see Backtracking.

Начиная с .NET Framework 4.5.NET Framework 4.5, вы можете определить интервал времени ожидания для совпадения с регулярными выражениями.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. Если обработчик регулярных выражений не может определить соответствие, в течение этого интервала времени, создает операцию сопоставления RegexMatchTimeoutException исключение.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. В большинстве случаев это не позволяет обработчику регулярных выражений тратить энергию обработки при попытке сопоставить текст, почти соответствующий шаблону регулярного выражения.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. Он также может указывать, тем не менее, что интервал времени ожидания было установлено слишком низкое, или что текущей загрузки компьютеров вызвала Общее снижение производительности.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.

Как обрабатывать исключение зависит от причины исключения.How you handle the exception depends on the cause of the exception. Если исключение происходит из-за слишком малое значение истечения времени ожидания или из-за чрезмерного машины нагрузки, можно увеличить интервал времени ожидания и повторите операцию сопоставления.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. Если исключение возникает, так как регулярное выражение использует избыточный поиск с возвратом, можно предположить, что соответствие не существует, и при необходимости можно записывать в журнал сведения, которые помогут вам изменить шаблон регулярного выражения.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.

Можно задать интервал времени ожидания путем вызова Regex(String, RegexOptions, TimeSpan) конструктор при создании экземпляра объекта регулярного выражения.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. Для статических методов, можно задать интервал времени ожидания путем вызова перегрузки метода сопоставления, который имеет matchTimeout параметра.For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. Если значение времени ожидания не задано явно, то значение времени ожидания по умолчанию определяется следующим образом:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • С помощью задания времени ожидания приложения. значение, если он существует.By using the application-wide time-out value, if one exists. Это может быть любым значением времени ожидания, который применяется в домен приложения, в котором Regex создается экземпляр объекта или вызов статического метода.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. Можно задать значение времени ожидания для всего приложения, вызвав AppDomain.SetData метод назначения строковым представлением TimeSpan значение к свойству «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.

  • С помощью значения InfiniteMatchTimeout, если значение времени ожидания для всего приложения не было задано.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Важно!

Мы рекомендуем создать значение времени ожидания во всех операциях поиска совпадения с шаблоном регулярного выражения.We recommend that you set a time-out value in all regular expression pattern-matching operations. Дополнительные сведения см. в разделе рекомендации по использованию регулярных выражений.For more information, see Best Practices for Regular Expressions.

К "Примечания"Back to Remarks

Конструкторы

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

Инициализирует новый экземпляр класса Regex.Initializes a new instance of the Regex class.

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

Инициализирует новый экземпляр класса Regex, используя сериализованные данные.Initializes a new instance of the Regex class by using serialized data.

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

Инициализирует новый экземпляр класса Regex для заданного регулярного выражения.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)

Инициализирует новый экземпляр класса Regex для указанного регулярного выражения с параметрами, изменяющими шаблон.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)

Инициализирует новый экземпляр класса Regex для указанного регулярного выражения с параметрами, которые изменяют шаблон, и значение, указывающее, как долго метод сравнения с шаблоном должен пытаться найти совпадение, прежде чем время ожидания истечет.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.

Поля

capnames capnames capnames capnames

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

caps caps caps caps

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capsize capsize capsize capsize

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

capslist capslist capslist capslist

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

factory factory factory factory

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout

Указывает, что для операции сравнения с шаблоном не используется конечное время ожидания.Specifies that a pattern-matching operation should not time out.

internalMatchTimeout internalMatchTimeout internalMatchTimeout internalMatchTimeout

Максимальное время, которое может пройти в операции сравнения с шаблоном перед истечением срока ожидания операции.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern pattern pattern pattern

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

roptions roptions roptions roptions

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

Свойства

CacheSize CacheSize CacheSize CacheSize

Возвращает или задает максимальное количество записей в текущей статической кэш-памяти скомпилированных регулярных выражений.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames CapNames CapNames CapNames

Получает или задает словарь, сопоставляющий именованные захватываемые группы со значениями их индексов.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps Caps Caps Caps

Получает или задает словарь, сопоставляющий нумерованные захватываемые группы со значениями их индексов.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout MatchTimeout MatchTimeout MatchTimeout

Получает интервал времени ожидания текущего экземпляра.Gets the time-out interval of the current instance.

Options Options Options Options

Получает параметр, которые были переданы в конструктор Regex.Gets the options that were passed into the Regex constructor.

RightToLeft RightToLeft RightToLeft RightToLeft

Получает значение, указывающее на то, выполняется ли регулярным выражением поиск справа налево.Gets a value that indicates whether the regular expression searches from right to left.

Методы

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

Компилирует один или несколько указанных объектов Regex в именованную сборку.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[])

Компилирует один или несколько указанных объектов Regex в именованную сборку с заданными атрибутами.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)

Компилирует один или несколько указанных объектов Regex и указанный файл ресурсов в именованную сборку с заданными атрибутами.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)

Определяет, равен ли заданный объект текущему объекту.Determines whether the specified object is equal to the current object.

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

Преобразует минимальный набор символов (\, *, +, ?, |, {, [, (,), ^, $,., # и пробел), заменяя их escape-кодами.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. При этом обработчику регулярных выражений дается команда интерпретировать эти символы буквально, а не как метасимволы.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

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

Этот член переопределяет Finalize(); по данной теме может быть доступна более полная документация.This member overrides Finalize(), and more complete documentation might be available in that topic.

Позволяет объекту Object попытаться освободить ресурсы и выполнить другие операции очистки, перед тем как объект Object будет утилизирован в процессе сборки мусора.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()

Возвращает массив имен группы записи для регулярного выражения.Returns an array of capturing group names for the regular expression.

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

Возвращает массив номеров групп записи, что соответствует именам групп в массиве.Returns an array of capturing group numbers that correspond to group names in an array.

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

Служит хэш-функцией по умолчанию.Serves as the default hash function.

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

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

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

Получает имя группы, соответствующее указанному номеру группы.Gets the group name that corresponds to the specified group number.

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

Возвращает номер группы, соответствующий указанному имени группы.Returns the group number that corresponds to the specified group name.

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

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

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

Указывает, обнаружено ли в указанной входной строке соответствие регулярному выражению, заданному в конструкторе Regex.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)

Указывает, обнаружено ли в указанной входной строке соответствие (начинающееся с указанной позиции в этой строке) регулярному выражению, заданному в конструкторе Regex.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)

Указывает, обнаружено ли в указанной входной строке соответствие заданному регулярному выражению.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)

Указывает, обнаружено ли в указанной входной строке соответствие заданному регулярному выражению, используя указанные параметры сопоставления.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)

Указывает, обнаружено ли в указанной входной строке соответствие заданному регулярному выражению, с помощью указанных параметров сопоставления и интервала времени ожидания.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)

Ищет в указанной входной строке первое вхождение регулярного выражения, указанного в конструкторе Regex.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)

Ищет во входной строке первое вхождение регулярного выражения, начиная с указанной начальной позиции.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)

Ищет во входной строке первое вхождение регулярного выражения, начиная с указанной начальной позиции и выполняя поиск только по указанному количеству символов.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)

Ищет в указанной входной строке первое вхождение заданного регулярного выражения.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)

Ищет во входной строке первое вхождение заданного регулярного выражения, используя указанные параметры сопоставления.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)

Ищет во входной строке первое вхождение заданного регулярного выражения, используя указанные параметры сопоставления и интервал времени ожидания.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)

Ищет в указанной входной строке все вхождения регулярного выражения.Searches the specified input string for all occurrences of a regular expression.

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

Ищет в указанной входной строке все вхождения регулярного выражения, начиная с указанной начальной позиции.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)

Ищет в указанной входной строке все вхождения заданного регулярного выражения.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)

Ищет в указанной входной строке все вхождения заданного регулярного выражения, используя указанные параметры сопоставления.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)

Ищет в указанной входной строке все вхождения заданного регулярного выражения, используя указанные параметры сопоставления и интервал времени ожидания.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()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

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

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.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)

В указанной входной строке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом MatchEvaluator.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)

В указанной входной подстроке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом MatchEvaluator.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)

В указанной входной строке заменяет все строки, соответствующие шаблону регулярного выражения, указанной строкой замены.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)

В указанной входной строке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.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)

В указанной входной подстроке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.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)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.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)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Указанные параметры изменяют операцию сопоставления.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)

В указанной входной строке заменяет все подстроки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.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)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены.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)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Указанные параметры изменяют операцию сопоставления.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)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.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)

Разделяет входную строку в массив подстрок в позициях, определенных шаблоном регулярного выражения, указанным в конструкторе Regex.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)

Разделяет входную строку указанное максимальное количество раз в массив подстрок в позициях, определенных регулярным выражением, указанным в конструкторе Regex.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)

Разделяет входную строку указанное максимальное количество раз в массив подстрок в позициях, определенных регулярным выражением, указанным в конструкторе Regex.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. Поиск шаблона регулярного выражения начинается с указанной позиции элемента во входной строке.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)

Разделяет входную строку в массив подстрок в позициях, определенных шаблоном регулярного выражения.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)

Разделяет входную строку в массив подстрок в позициях, определенных указанным шаблоном регулярного выражения.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Указанные параметры изменяют операцию сопоставления.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)

Разделяет входную строку в массив подстрок в позициях, определенных указанным шаблоном регулярного выражения.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

Возвращает шаблон регулярного выражения, который был передан в конструктор Regex.Returns the regular expression pattern that was passed into the Regex constructor.

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

Преобразует все escape-символы во входной строке обратно в символы.Converts any escaped characters in the input string.

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

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

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

Используется объектом Regex, который создан методом CompileToAssembly.Used by a Regex object generated by the CompileToAssembly method.

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

Проверяет, попадает ли интервал времени ожидания в допустимый диапазон.Checks whether a time-out interval is within an acceptable range.

Явные реализации интерфейса

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

Заполняет объект SerializationInfo данными даты, необходимыми для десериализации текущего объекта Regex.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

Применяется к

Потокобезопасность

Regex Класс является неизменяемым (только для чтения) и является потокобезопасным.The Regex class is immutable (read-only) and thread safe. Regex объекты могут создаваться в любом потоке и совместно использоваться несколькими потоками.Regex objects can be created on any thread and shared between threads. Дополнительные сведения см. в разделе потокобезопасность.For more information, see Thread Safety.

Дополнительно