Regex Regex Regex Regex Constructors

Определение

Перегрузки

Regex() Regex() Regex()

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

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

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

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, 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.

Regex() Regex() Regex()

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

protected:
 Regex();
protected Regex ();
Protected Sub New ()

Комментарии

Обратите внимание, что этот конструктор защищен; Он может вызываться только классами, производными Regex от класса.Note that this constructor is protected; it can only be called by classes derived from the Regex class.

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

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

public:
 Regex(System::String ^ pattern);
public Regex (string pattern);
new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String)

Параметры

pattern
String String String String

Шаблон регулярного выражения для сопоставления.The regular expression pattern to match.

Исключения

Произошла ошибка анализа регулярного выражения.A regular expression parsing error occurred.

Примеры

В следующем примере показано, как использовать этот конструктор для создания экземпляра регулярного выражения, совпадающего с любым словом, начинающимся с букв "a" или "t".The following example illustrates how to use this constructor to instantiate a regular expression that matches any word that begins with the letters "a" or "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Обратите внимание, что шаблон регулярного выражения не может соответствовать слову «the» в начале текста, поскольку при сравнении по умолчанию учитывается регистр.Note that the regular expression pattern cannot match the word "The" at the beginning of the text, because comparisons are case-sensitive by default. Пример сравнения без учета регистра см. в Regex(String, RegexOptions) описании конструктора.For an example of case-insensitive comparison, see the Regex(String, RegexOptions) constructor.

Комментарии

pattern Параметр состоит из элементов языка регулярных выражений, которые в символьном виде описывают строку для сопоставления.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Дополнительные сведения о регулярных выражениях см. в разделе .NET Framework регулярные выражения и Язык регулярных выражений — краткие справочные материалы.For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Вызов конструктора эквивалентен Regex(String, RegexOptions) вызову None конструктора со значением для options аргумента. Regex(String)Calling the Regex(String) constructor is equivalent to calling the Regex(String, RegexOptions) constructor with a value of None for the options argument.

Regex Объект является неизменяемым. Это означает, что его можно использовать только для шаблона соответствия, который вы определили при его создании.A Regex object is immutable, which means that it can be used only for the match pattern you define when you create it. Однако его можно использовать любое количество раз без повторной компиляции.However, it can be used any number of times without being recompiled.

Этот конструктор создает экземпляр объекта регулярного выражения, который пытается выполнить поиск с учетом регистра любых алфавитных patternсимволов, определенных в.This constructor instantiates a regular expression object that attempts a case-sensitive match of any alphabetical characters defined in pattern. Для совпадения без учета регистра используйте Regex.Regex(String, RegexOptions) конструктор.For a case-insensitive match, use the Regex.Regex(String, RegexOptions) constructor.

Примечания для тех, кто вызывает этот метод

Этот конструктор создает Regex объект, который использует значение времени ожидания по умолчанию для домена приложения, в котором он создается.This constructor creates a Regex object that uses the default time-out value of the application domain in which it is created. Если значение времени ожидания не было определено для домена приложения, Regex объект использует значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания операции. Для создания Regex Regex(String, RegexOptions, TimeSpan)объекта рекомендуется использовать конструктор, который позволяет задать интервал времени ожидания.If a time-out value has not been defined for the application domain, the Regex object uses the value InfiniteMatchTimeout, which prevents the operation from timing out. The recommended constructor for creating a Regex object is Regex(String, RegexOptions, TimeSpan), which lets you set the time-out interval.

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

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.

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
Protected Sub New (info As SerializationInfo, context As StreamingContext)

Параметры

info
SerializationInfo SerializationInfo SerializationInfo SerializationInfo

Объект, содержащий сериализованный шаблон и сведения RegexOptions.The object that contains a serialized pattern and RegexOptions information.

context
StreamingContext StreamingContext StreamingContext StreamingContext

Целевой объект этой сериализации.The destination for this serialization. (Этот параметр не используется; задайте значение null.)(This parameter is not used; specify null.)

Исключения

Произошла ошибка анализа регулярного выражения.A regular expression parsing error occurred.

Шаблон, содержащий info, имеет значение null.The pattern that info contains is null.

info содержит недопустимый флаг RegexOptions.info contains an invalid RegexOptions flag.

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.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions)

Параметры

pattern
String String String String

Шаблон регулярного выражения для сопоставления.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Побитовое сочетание значений перечисления, изменяющих регулярное выражение.A bitwise combination of the enumeration values that modify the regular expression.

Исключения

Произошла ошибка анализа регулярного выражения.A regular expression parsing error occurred.

Свойство pattern имеет значение null.pattern is null.

options содержит недопустимый флаг.options contains an invalid flag.

Примеры

В следующем примере показано, как использовать этот конструктор для создания экземпляра регулярного выражения, совпадающего с любым словом, начинающимся с букв "a" или "t".The following example illustrates how to use this constructor to instantiate a regular expression that matches any word that begins with the letters "a" or "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Обратите внимание, что коллекция Match включает слово «The», которое начинается с текста options , поскольку параметр определяет сравнение без учета регистра.Note that the match collection includes the word "The" that begins the text because the options parameter has defined case-insensitive comparisons.

Комментарии

pattern Параметр состоит из элементов языка регулярных выражений, которые в символьном виде описывают строку для сопоставления.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Дополнительные сведения о регулярных выражениях см. в разделе .NET Framework регулярные выражения и Язык регулярных выражений — краткие справочные материалы.For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Regex Объект является неизменяемым. Это означает, что его можно использовать только для параметров соответствия, которые вы определяете при его создании.A Regex object is immutable, which means that it can be used only for the match parameters you define when you create it. Однако его можно использовать любое количество раз без повторной компиляции.However, it can be used any number of times without being recompiled.

Примечания для тех, кто вызывает этот метод

Этот конструктор создает Regex объект, который использует значение времени ожидания по умолчанию для домена приложения, в котором он создается.This constructor creates a Regex object that uses the default time-out value of the application domain in which it is created. Если значение времени ожидания не было определено для домена приложения, Regex объект использует значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания операции. Для создания Regex Regex(String, RegexOptions, TimeSpan)объекта рекомендуется использовать конструктор, который позволяет задать интервал времени ожидания.If a time-out value has not been defined for the application domain, the Regex object uses the value InfiniteMatchTimeout, which prevents the operation from timing out. The recommended constructor for creating a Regex object is Regex(String, RegexOptions, TimeSpan), which lets you set the time-out interval.

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

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.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex
Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Параметры

pattern
String String String String

Шаблон регулярного выражения для сопоставления.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Побитовое сочетание значений перечисления, изменяющих регулярное выражение.A bitwise combination of the enumeration values that modify the regular expression.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Интервал времени ожидания или InfiniteMatchTimeout, чтобы указать, что метод не должен превышать время ожидания.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Исключения

Произошла ошибка анализа регулярного выражения.A regular expression parsing error occurred.

Свойство pattern имеет значение null.pattern is null.

options не является допустимым значением RegexOptions.options is not a valid RegexOptions value.

- или --or- Значение параметра matchTimeout отрицательное, равно нулю или больше, чем приблизительно 24 дня.matchTimeout is negative, zero, or greater than approximately 24 days.

Примеры

В следующем примере вызывается Regex(String, RegexOptions, TimeSpan) конструктор для создания экземпляра Regex объекта со значением времени ожидания, равным одной секунде.The following example calls the Regex(String, RegexOptions, TimeSpan) constructor to instantiate a Regex object with a time-out value of one second. Шаблон регулярного выражения (a+)+$, который сопоставляется с последовательностью из одного или нескольких символов "a" в конце строки, относится к шаблонам с чрезмерным использованием поиска с возвратом.The regular expression pattern (a+)+$, which matches one or more sequences of one or more "a" characters at the end of a line, is subject to excessive backtracking. RegexMatchTimeoutException При возникновении исключения в примере значение времени ожидания увеличивается до максимального значения, равного трем секундам.If a RegexMatchTimeoutException is thrown, the example increases the time-out value up to the maximum value of three seconds. В противном случае он отказывается от попытки сопоставить шаблон.Otherwise, it abandons the attempt to match the pattern.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

Комментарии

pattern Параметр состоит из элементов языка регулярных выражений, которые в символьном виде описывают строку для сопоставления.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Дополнительные сведения о регулярных выражениях см. в разделе .NET Framework регулярные выражения и Язык регулярных выражений — краткие справочные материалы.For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Regex Объект является неизменяемым. Это означает, что его можно использовать только для шаблона соответствия, который вы определили при его создании.A Regex object is immutable, which means that it can be used only for the match pattern that you define when you create it. Однако его можно использовать любое количество раз без повторной компиляции.However, it can be used any number of times without being recompiled.

matchTimeout Параметр указывает, как долго метод сопоставления шаблонов должен попытаться найти соответствие до истечения времени ожидания. Если в течение этого интервала времени совпадения не найдены, метод сопоставления шаблонов создает RegexMatchTimeoutException исключение.The matchTimeout parameter specifies how long a pattern-matching method should try to find a match before it times out. If no match is found in that time interval, the pattern-matching method throws a RegexMatchTimeoutException exception. matchTimeoutпереопределяет любое значение времени ожидания по умолчанию, определенное для домена приложения, Regex в котором создается объект.matchTimeout overrides any default time-out value defined for the application domain in which the Regex object is created. Методы сопоставления шаблона экземпляра, которые последают matchTimeout за интервал времени ожидания, включают следующее:The instance pattern-matching methods that observe the matchTimeout time-out interval include the following:

Установка интервала времени ожидания предотвращает зависание регулярных выражений, которые полагаются на избыточное выполнение поиска с возвратом, при обработке входных данных, содержащих близкие совпадения.Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Дополнительные сведения см. в разделе рекомендации по использованию регулярных выражений и поискас возвратом.For more information, see Best Practices for Regular Expressions and Backtracking. Для установки разумного интервала времени ожидания учитывайте следующие факторы.To set a reasonable time-out interval, consider the following factors:

  • Длина и сложность шаблона регулярного выражения.The length and complexity of the regular expression pattern. Более длинные и более сложные регулярные выражения требуют больше времени, чем более короткие и простые.Longer and more complex regular expressions require more time than shorter and simpler ones.

  • Ожидаемая загрузка компьютера.The expected machine load. Обработка занимает больше времени на системах с высоким уровнем использования ЦП и памяти.Processing takes more time on systems that have high CPU and memory utilization.

Примечания для тех, кто вызывает этот метод

Рекомендуется присвоить matchTimeout параметру соответствующее значение, например две секунды.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Если вы отключаете время ожидания, указав InfiniteMatchTimeout, механизм регулярных выражений обеспечивает немного более высокую производительность.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Однако время ожидания следует отключить только при следующих условиях.However, you should disable time-outs only under the following conditions: — Если входные данные, обрабатываемые регулярным выражением, являются производными от известного и надежного источника или состоят из статического текста.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Это исключает текст, введенный пользователями динамически.This excludes text that has been dynamically input by users.

— При тщательном тестировании шаблона регулярного выражения для обеспечения эффективной обработки совпадений, несоответствий и близких соответствий.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

— Если шаблон регулярного выражения не содержит элементов языка, которые вызывают избыточный поиск с возвратом при обработке близкого соответствия.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

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

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