Regex Класс

Определение

Представляет постоянное регулярное выражение.

public ref class Regex
public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
type Regex = class
    interface ISerializable
[<System.Serializable>]
type Regex = class
    interface ISerializable
Public Class Regex
Public Class Regex
Implements ISerializable
Наследование
Regex
Производный
Атрибуты
Реализации

Примеры

В следующем примере регулярное выражение используется для проверки повторяющегося вхождения слов в строке. Регулярное выражение \b(?<word>\w+)\s+(\k<word>)\b можно интерпретировать, как показано в следующей таблице.

Шаблон Описание
\b Начните совпадение с границы слова.
(?<word>\w+) Сопоставление одного или нескольких символов слова до границы слова. Назовите эту захватываемую группу word.
\s+ Совпадение с одним или несколькими пробелами.
(\k<word>) Соответствует захватываемой группе с именем word.
\b Соответствует границе слова.
#using <System.dll>

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

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

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

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

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

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

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

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

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

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

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

Public Module Test

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

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

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

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

В следующем примере показано использование регулярного выражения для проверки того, представляет ли строка значение валюты или имеет ли правильный формат для представления значения валюты. В этом случае регулярное выражение создается динамически на основе NumberFormatInfo.CurrencyDecimalSeparatorсвойств , CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSignи для текущего языка и NumberFormatInfo.PositiveSign региональных параметров пользователя. Если текущий язык и региональные параметры системы — en-US, результирующее регулярное выражение — ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Это регулярное выражение можно интерпретировать, как показано в следующей таблице.

Шаблон Описание
^ Начните с начала строки.
\s* Соответствует нулю или нескольким символам пробела.
[\+-]? Соответствует нулю или одному вхождениям положительного или отрицательного знака.
\s? Совпадение с нулем или одним символом пробела.
\$? Соответствует нулю или одному вхождениям знака доллара.
\s? Совпадение с нулем или одним символом пробела.
\d* Соответствует нулю или нескольким десятичным числам.
\.? Соответствует нулю или одному символу десятичной запятой.
\d{2}? Совпадение с двумя десятичными цифрами ноль или один раз.
(\d*\.?\d{2}?){1} Совпадение с шаблоном целочисленных и дробных цифр, разделенных символом десятичной запятой, по крайней мере один раз.
$ Соответствует концу строки.

В этом случае регулярное выражение предполагает, что допустимая строка валюты не содержит символов разделителя групп и что в ней отсутствуют дробные цифры или число дробных цифр, определенное свойством текущего CurrencyDecimalDigits языка и региональных параметров.

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

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

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

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

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

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = NumberFormatInfo.CurrentInfo

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

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

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

Так как регулярное выражение в этом примере создается динамически, во время разработки мы не знаем, могут ли символы валюты, десятичные знаки или положительные и отрицательные знаки текущего языка и региональных параметров быть неправильно интерпретированы обработчиком регулярных выражений как операторы языка регулярных выражений. Чтобы предотвратить неправильное толкование, в примере каждая динамически создаваемая строка передается в Escape метод .

Комментарии

Класс Regex представляет обработчик регулярных выражений платформа .NET Framework. Его можно использовать для быстрого анализа больших объемов текста для поиска определенных шаблонов символов; для извлечения, изменения, замены или удаления текстовых подстрок; и для добавления извлеченных строк в коллекцию для создания отчета.

Примечание

Если основной интерес — проверить строку, определив, соответствует ли она определенному шаблону System.Configuration.RegexStringValidator , можно использовать класс .

Для использования регулярных выражений вы определяете шаблон, который нужно определить в текстовом потоке, с помощью синтаксиса, описанного в разделе Язык регулярных выражений — краткий справочник. Затем при необходимости можно создать Regex экземпляр объекта . Наконец, вызывается метод, который выполняет определенную операцию, например замену текста, соответствующего шаблону регулярного выражения, или определение соответствия шаблону.

Примечание

Некоторые распространенные шаблоны регулярных выражений см. в разделе Примеры регулярных выражений. Существует также ряд интерактивных библиотек шаблонов регулярных выражений, например библиотеки на Regular-Expressions.info.

Дополнительные сведения об использовании Regex класса см. в следующих разделах этой статьи:

Дополнительные сведения о языке регулярных выражений см. в кратком справочнике по элементам языка регулярных выражений или в одной из следующих брошюр, который вы можете скачать и распечатать:

Краткий справочник в формате Word (DOCX);
Краткий справочник в формате PDF (PDF).

Регулярное выражение и строковые методы

Класс System.String включает несколько методов поиска и сравнения, которые можно использовать для сопоставления шаблонов с текстом. Например, методы , и определяют, String.Containsсодержит ли экземпляр строки указанную подстроку; String.IndexOfметоды , String.IndexOfAny, String.LastIndexOfи String.LastIndexOfAny возвращают начальную позицию указанной подстроки в строке.String.StartsWithString.EndsWith Используйте методы класса при System.String поиске определенной строки. Regex Используйте класс при поиске определенного шаблона в строке. Дополнительные сведения и примеры см. в разделе Регулярные выражения .NET.

Вернуться к примечаниям

Статические методы и методы экземпляра

После определения шаблона регулярного выражения его можно предоставить обработчику регулярных выражений двумя способами:

  • Путем создания экземпляра Regex объекта , представляющего регулярное выражение. Для этого необходимо передать шаблон регулярного Regex выражения в конструктор. Объект Regex является неизменяемым; при создании экземпляра Regex объекта с регулярным выражением регулярное выражение этого объекта нельзя изменить.

  • Путем предоставления регулярного выражения и текста для поиска static в метод (Shared в Visual Basic). Regex Это позволяет использовать регулярное выражение без явного Regex создания объекта .

Все Regex методы идентификации шаблонов включают как статические, так и экземплярные перегрузки.

Перед использованием шаблона обработчик регулярных выражений должен скомпилировать определенный шаблон. Поскольку Regex объекты являются неизменяемыми, это однократная процедура, которая выполняется при вызове Regex конструктора класса или статического метода. Чтобы исключить необходимость многократной компиляции одного регулярного выражения, обработчик регулярных выражений кэширует скомпилированные регулярные выражения, используемые в вызовах статических методов. В результате методы сопоставления шаблонов регулярных выражений обеспечивают сравнимую производительность статических методов и методов экземпляра.

Важно!

В платформа .NET Framework версиях 1.0 и 1.1 все скомпилированные регулярные выражения, независимо от того, использовались ли они в вызовах экземпляров или статических методов, были кэшированы. Начиная с платформа .NET Framework 2.0 кэшируются только регулярные выражения, используемые в вызовах статических методов.

Однако кэширование может негативно повлиять на производительность в следующих двух случаях:

  • При использовании вызовов статических методов с большим количеством регулярных выражений. По умолчанию обработчик регулярных выражений кэширует 15 последних использованных статических регулярных выражений. Если приложение использует более 15 статических регулярных выражений, некоторые регулярные выражения необходимо перекомпилировать. Чтобы предотвратить повторную компиляцию Regex.CacheSize , можно увеличить свойство .

  • При создании экземпляров новых Regex объектов с регулярными выражениями, которые были ранее скомпилированы. Например, следующий код определяет регулярное выражение для поиска повторяющихся слов в текстовом потоке. Хотя в примере используется одно регулярное выражение, он создает экземпляр нового Regex объекта для обработки каждой строки текста. Это приводит к перекомпиляции регулярного выражения с каждой итерацией цикла.

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

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

Вернуться к примечаниям

Выполнение операций с регулярными выражениями

Независимо от того, решите ли вы создать Regex экземпляр объекта и вызвать его методы или вызвать статические Regex методы, класс предлагает следующие функции сопоставления шаблонов:

  • Проверка соответствия. Вызывается метод , IsMatch чтобы определить, присутствует ли совпадение.

  • Получение одного совпадения. Метод вызывается Match для получения Match объекта , представляющего первое совпадение в строке или части строки. Последующие совпадения можно получить, вызвав Match.NextMatch метод .

  • Получение всех совпадений. Метод вызывается Matches для получения System.Text.RegularExpressions.MatchCollection объекта , представляющего все совпадения, найденные в строке или части строки.

  • Замена совпадающего текста. Для замены Replace совпадающего текста вызывается метод . Замещающий текст также можно определить с помощью регулярного выражения. Кроме того, некоторые Replace методы включают MatchEvaluator параметр, позволяющий программно определить замещающий текст.

  • Создание массива строк, сформированного из частей входной строки. Метод вызывается для Split разделения входной строки по позициям, определенным регулярным выражением.

Помимо методов сопоставления шаблонов, Regex класс включает несколько специальных методов:

  • Метод Escape экранирует все символы, которые могут быть интерпретированы как операторы регулярных выражений в регулярном выражении или входной строке.

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

  • Метод CompileToAssembly создает сборку, содержащую предопределенные регулярные выражения. Платформа .NET Framework содержит примеры этих специальных сборок в System.Web.RegularExpressions пространстве имен.

Вернуться к примечаниям

Определение значения Time-Out

.NET поддерживает полнофункциональный язык регулярных выражений, обеспечивающий значительную мощность и гибкость при сопоставлении шаблонов. Тем не менее, мощность и гибкость стоят дорого: риск низкой производительности. Регулярные выражения, которые работают плохо, на удивление легко создавать. В некоторых случаях операции регулярных выражений, которые зависят от чрезмерного отслеживания, могут перестать отвечать на запросы при обработке текста, который почти соответствует шаблону регулярного выражения. Дополнительные сведения о обработчике регулярных выражений .NET см. в разделе Сведения о поведении регулярных выражений. Дополнительные сведения о чрезмерном возврате см. в разделе Backtracking.

Начиная с платформа .NET Framework 4.5, можно определить интервал времени ожидания для совпадений регулярных выражений, чтобы ограничить чрезмерное количество обратных запросов. В зависимости от шаблона регулярного выражения и входного текста время выполнения может превышать указанный интервал времени ожидания, но не будет тратить больше времени на поиск, чем указанный интервал времени ожидания. Если время ожидания обработчика регулярных выражений RegexMatchTimeoutException истекает, возникает исключение. В большинстве случаев это не позволяет обработчику регулярных выражений тратить вычислительную мощность, пытаясь сопоставить текст, который почти соответствует шаблону регулярного выражения. Однако это также может указывать на то, что интервал времени ожидания слишком низкий или что текущая нагрузка на компьютер привела к общему снижению производительности.

Способ обработки исключения зависит от причины исключения. Если исключение возникает из-за слишком низкого интервала ожидания или из-за чрезмерной нагрузки компьютера, можно увеличить интервал времени ожидания и повторить операцию сопоставления. Если исключение возникает из-за того, что регулярное выражение использует чрезмерное отслеживание, можно предположить, что совпадения не существует, и при необходимости можно записать в журнал сведения, которые помогут изменить шаблон регулярного выражения.

Интервал времени ожидания можно задать путем вызова конструктора Regex(String, RegexOptions, TimeSpan) при создании экземпляра объекта регулярного выражения. Для статических методов можно задать интервал времени ожидания, вызвав перегрузку соответствующего метода с параметром matchTimeout . Если значение времени ожидания не задано явным образом, значение времени ожидания по умолчанию определяется следующим образом:

  • С помощью значения времени ожидания на уровне приложения, если оно существует. Это может быть любое значение времени ожидания, которое применяется к домену приложения, в котором Regex создается экземпляр объекта или выполняется вызов статического метода. Значение времени ожидания для всего приложения можно задать, вызвав AppDomain.SetData метод , чтобы присвоить строковое представление TimeSpan значения свойству "REGEX_DEFAULT_MATCH_TIMEOUT".

  • При использовании значения InfiniteMatchTimeout, если значение времени ожидания на уровне приложения не задано.

Важно!

Рекомендуется задать значение времени ожидания во всех операциях сопоставления шаблонов регулярных выражений. Дополнительные сведения см. в разделе Рекомендации по использованию регулярных выражений.

Вернуться к примечаниям

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

Regex()

Инициализирует новый экземпляр класса Regex.

Regex(SerializationInfo, StreamingContext)

Инициализирует новый экземпляр класса Regex, используя сериализованные данные.

Regex(String)

Инициализирует новый экземпляр класса Regex для заданного регулярного выражения.

Regex(String, RegexOptions)

Инициализирует новый экземпляр класса Regex для указанного регулярного выражения с параметрами, изменяющими шаблон.

Regex(String, RegexOptions, TimeSpan)

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

Поля

capnames

Используется объектом Regex, который создан методом CompileToAssembly.

caps

Используется объектом Regex, который создан методом CompileToAssembly.

capsize

Используется объектом Regex, который создан методом CompileToAssembly.

capslist

Используется объектом Regex, который создан методом CompileToAssembly.

factory

Используется объектом Regex, который создан методом CompileToAssembly.

InfiniteMatchTimeout

Указывает, что для операции сравнения с шаблоном не используется конечное время ожидания.

internalMatchTimeout

Максимальное время, которое может пройти в операции сравнения с шаблоном перед истечением срока ожидания операции.

pattern

Используется объектом Regex, который создан методом CompileToAssembly.

roptions

Используется объектом Regex, который создан методом CompileToAssembly.

Свойства

CacheSize

Возвращает или задает максимальное количество записей в текущей статической кэш-памяти скомпилированных регулярных выражений.

CapNames

Получает или задает словарь, сопоставляющий именованные захватываемые группы со значениями их индексов.

Caps

Получает или задает словарь, сопоставляющий нумерованные захватываемые группы со значениями их индексов.

MatchTimeout

Получает интервал времени ожидания текущего экземпляра.

Options

Получает параметр, которые были переданы в конструктор Regex.

RightToLeft

Получает значение, указывающее на то, выполняется ли регулярным выражением поиск справа налево.

Методы

CompileToAssembly(RegexCompilationInfo[], AssemblyName)
Является устаревшей.

Компилирует один или несколько указанных объектов Regex в именованную сборку.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])
Является устаревшей.

Компилирует один или несколько указанных объектов Regex в именованную сборку с заданными атрибутами.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)
Является устаревшей.

Компилирует один или несколько указанных объектов Regex и указанный файл ресурсов в именованную сборку с заданными атрибутами.

Count(ReadOnlySpan<Char>)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает количество совпадений.

Count(ReadOnlySpan<Char>, Int32)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает количество совпадений.

Count(ReadOnlySpan<Char>, String)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает количество совпадений.

Count(ReadOnlySpan<Char>, String, RegexOptions)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает количество совпадений.

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

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает количество совпадений.

Count(String)

Выполняет поиск во входной строке всех вхождений регулярного выражения и возвращает количество совпадений.

Count(String, String)

Выполняет поиск во входной строке всех вхождений регулярного выражения и возвращает количество совпадений.

Count(String, String, RegexOptions)

Выполняет поиск во входной строке всех вхождений регулярного выражения и возвращает количество совпадений.

Count(String, String, RegexOptions, TimeSpan)

Выполняет поиск во входной строке всех вхождений регулярного выражения и возвращает количество совпадений.

EnumerateMatches(ReadOnlySpan<Char>)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает Regex.ValueMatchEnumerator для итерации по совпадениям.

EnumerateMatches(ReadOnlySpan<Char>, Int32)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает Regex.ValueMatchEnumerator для итерации по совпадениям.

EnumerateMatches(ReadOnlySpan<Char>, String)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает Regex.ValueMatchEnumerator для итерации по совпадениям.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает Regex.ValueMatchEnumerator для итерации по совпадениям.

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

Выполняет поиск входного диапазона для всех вхождений регулярного выражения и возвращает Regex.ValueMatchEnumerator для итерации по совпадениям.

Equals(Object)

Определяет, равен ли указанный объект текущему объекту.

(Унаследовано от Object)
Escape(String)

Экранирует минимальный набор символов (\, *, +, ?, |, {, [, (,), ^, $, ., #и пробелы, заменяя их escape-кодами. При этом обработчику регулярных выражений дается команда интерпретировать эти символы буквально, а не как метасимволы.

Finalize()

Этот член переопределяет Finalize(); по данной теме может быть доступна более полная документация.

Позволяет объекту Object попытаться освободить ресурсы и выполнить другие операции очистки, перед тем как объект Object будет утилизирован в процессе сборки мусора.

GetGroupNames()

Возвращает массив имен группы записи для регулярного выражения.

GetGroupNumbers()

Возвращает массив номеров групп записи, что соответствует именам групп в массиве.

GetHashCode()

Служит хэш-функцией по умолчанию.

(Унаследовано от Object)
GetType()

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

(Унаследовано от Object)
GroupNameFromNumber(Int32)

Получает имя группы, соответствующее указанному номеру группы.

GroupNumberFromName(String)

Возвращает номер группы, соответствующий указанному имени группы.

InitializeReferences()

Используется объектом Regex, который создан методом CompileToAssembly.

IsMatch(ReadOnlySpan<Char>)

Указывает, находит ли регулярное выражение, указанное в конструкторе регулярных выражений, совпадение в указанном входном диапазоне.

IsMatch(ReadOnlySpan<Char>, Int32)

Указывает, находит ли регулярное выражение, указанное в конструкторе регулярных выражений, совпадение в указанном входном диапазоне.

IsMatch(ReadOnlySpan<Char>, String)

Указывает, находит ли указанное регулярное выражение совпадение в указанном входном диапазоне.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Указывает, находит ли указанное регулярное выражение совпадение в указанном входном диапазоне с помощью указанных параметров сопоставления.

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

Указывает, находит ли указанное регулярное выражение совпадение в указанном входном диапазоне, используя указанные параметры сопоставления и интервал времени ожидания.

IsMatch(String)

Указывает, обнаружено ли в указанной входной строке соответствие регулярному выражению, заданному в конструкторе Regex.

IsMatch(String, Int32)

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

IsMatch(String, String)

Указывает, обнаружено ли в указанной входной строке соответствие заданному регулярному выражению.

IsMatch(String, String, RegexOptions)

Указывает, обнаружено ли в указанной входной строке соответствие заданному регулярному выражению, используя указанные параметры сопоставления.

IsMatch(String, String, RegexOptions, TimeSpan)

Указывает, обнаружено ли в указанной входной строке соответствие заданному регулярному выражению, с помощью указанных параметров сопоставления и интервала времени ожидания.

Match(String)

Ищет в указанной входной строке первое вхождение регулярного выражения, указанного в конструкторе Regex.

Match(String, Int32)

Ищет во входной строке первое вхождение регулярного выражения, начиная с указанной начальной позиции.

Match(String, Int32, Int32)

Ищет во входной строке первое вхождение регулярного выражения, начиная с указанной начальной позиции и выполняя поиск только по указанному количеству символов.

Match(String, String)

Ищет в указанной входной строке первое вхождение заданного регулярного выражения.

Match(String, String, RegexOptions)

Ищет во входной строке первое вхождение заданного регулярного выражения, используя указанные параметры сопоставления.

Match(String, String, RegexOptions, TimeSpan)

Ищет во входной строке первое вхождение заданного регулярного выражения, используя указанные параметры сопоставления и интервал времени ожидания.

Matches(String)

Ищет в указанной входной строке все вхождения регулярного выражения.

Matches(String, Int32)

Ищет в указанной входной строке все вхождения регулярного выражения, начиная с указанной начальной позиции.

Matches(String, String)

Ищет в указанной входной строке все вхождения заданного регулярного выражения.

Matches(String, String, RegexOptions)

Ищет в указанной входной строке все вхождения заданного регулярного выражения, используя указанные параметры сопоставления.

Matches(String, String, RegexOptions, TimeSpan)

Ищет в указанной входной строке все вхождения заданного регулярного выражения, используя указанные параметры сопоставления и интервал времени ожидания.

MemberwiseClone()

Создает неполную копию текущего объекта Object.

(Унаследовано от Object)
Replace(String, MatchEvaluator)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, MatchEvaluator, Int32)

В указанной входной строке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, MatchEvaluator, Int32, Int32)

В указанной входной подстроке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, String)

В указанной входной строке заменяет все строки, соответствующие шаблону регулярного выражения, указанной строкой замены.

Replace(String, String, Int32)

В указанной входной строке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.

Replace(String, String, Int32, Int32)

В указанной входной подстроке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.

Replace(String, String, MatchEvaluator)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, String, MatchEvaluator, RegexOptions)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator. Указанные параметры изменяют операцию сопоставления.

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

В указанной входной строке заменяет все подстроки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

Replace(String, String, String)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены.

Replace(String, String, String, RegexOptions)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены. Указанные параметры изменяют операцию сопоставления.

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

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

Split(String)

Разделяет входную строку в массив подстрок в позициях, определенных шаблоном регулярного выражения, указанным в конструкторе Regex.

Split(String, Int32)

Разделяет входную строку указанное максимальное количество раз в массив подстрок в позициях, определенных регулярным выражением, указанным в конструкторе Regex.

Split(String, Int32, Int32)

Разделяет входную строку указанное максимальное количество раз в массив подстрок в позициях, определенных регулярным выражением, указанным в конструкторе Regex. Поиск шаблона регулярного выражения начинается с указанной позиции элемента во входной строке.

Split(String, String)

Разделяет входную строку в массив подстрок в позициях, определенных шаблоном регулярного выражения.

Split(String, String, RegexOptions)

Разделяет входную строку в массив подстрок в позициях, определенных указанным шаблоном регулярного выражения. Указанные параметры изменяют операцию сопоставления.

Split(String, String, RegexOptions, TimeSpan)

Разделяет входную строку в массив подстрок в позициях, определенных указанным шаблоном регулярного выражения. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

ToString()

Возвращает шаблон регулярного выражения, который был передан в конструктор Regex.

Unescape(String)

Преобразует все escape-символы во входной строке обратно в символы.

UseOptionC()

Используется объектом Regex, который создан методом CompileToAssembly.

UseOptionR()

Используется объектом Regex, который создан методом CompileToAssembly.

ValidateMatchTimeout(TimeSpan)

Проверяет, попадает ли интервал времени ожидания в допустимый диапазон.

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

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Заполняет объект SerializationInfo данными даты, необходимыми для десериализации текущего объекта Regex.

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

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

Класс Regex является неизменяемым (только для чтения) и потокобезопасным. Regex Объекты могут создаваться в любом потоке и совместно использоваться потоками. Дополнительные сведения см. в разделе Потокобезопасность.

См. также раздел