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

Исходный код:

Regex.cs

Исходный код:

Regex.cs

Исходный код:

Regex.cs

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Комментарии

Обратите внимание, что этот конструктор защищен; его можно вызывать только классами, производными от класса Regex.

Исходный код:

Regex.cs

Исходный код:

Regex.cs

Исходный код:

Regex.cs

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)

Параметры

Исключения

Примеры

В следующем примере показано, как использовать этот конструктор для создания экземпляра регулярного выражения, соответствующего любому слову, начинающимся с букв "a" или "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" в начале текста, так как по умолчанию сравнения учитывает регистр. Пример сравнения без учета регистра см. в конструкторе Regex(String, RegexOptions).

Комментарии

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают строку для сопоставления. Дополнительные сведения о регулярных выражениях см. в разделах регулярных выражений .NET и языка регулярных выражений . Краткий справочник по разделам.

Вызов конструктора Regex(String) эквивалентен вызову конструктора Regex(String, RegexOptions) со значением None для аргумента options.

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

Этот конструктор создает экземпляр объекта регулярного выражения, который пытается сопоставить регистр любого алфавитного символа, определенного в pattern. Для сопоставления без учета регистра используйте конструктор Regex.Regex(String, RegexOptions).

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

Этот конструктор создает объект Regex, использующий значение времени ожидания по умолчанию домена приложения, в котором он создается. Если значение времени ожидания не определено для домена приложения, объект Regex использует значение InfiniteMatchTimeout, что предотвращает истечение времени ожидания операции. Рекомендуемый конструктор для создания объекта Regex является Regex(String, RegexOptions, TimeSpan), что позволяет задать интервал времени ожидания.

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

• элементы языка регулярных выражений

Исходный код:

Regex.cs

Исходный код:

Regex.cs

Исходный код:

Regex.cs

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
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

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
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)

Параметры

Атрибуты

ObsoleteAttribute

Исключения

Исходный код:

Regex.cs

Исходный код:

Regex.cs

Исходный код:

Regex.cs

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)

Параметры

Исключения

Примеры

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

Обратите внимание, что коллекция совпадений включает слово "The", которое начинает текст, так как параметр options определил нечувствительные сравнения регистра.

Комментарии

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают строку для сопоставления. Дополнительные сведения о регулярных выражениях см. в разделах регулярных выражений .NET и языка регулярных выражений . Краткий справочник по разделам.

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

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

Этот конструктор создает объект Regex, использующий значение времени ожидания по умолчанию домена приложения, в котором он создается. Если значение времени ожидания не определено для домена приложения, объект Regex использует значение InfiniteMatchTimeout, что предотвращает истечение времени ожидания операции. Рекомендуемый конструктор для создания объекта Regex является Regex(String, RegexOptions, TimeSpan), что позволяет задать интервал времени ожидания.

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

• элементы языка регулярных выражений

Исходный код:

Regex.cs

Исходный код:

Regex.cs

Исходный код:

Regex.cs

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)

Параметры

Исключения

Примеры

В следующем примере вызывается конструктор Regex(String, RegexOptions, TimeSpan) для создания экземпляра объекта Regex со значением времени ожидания в секунду. Шаблон регулярного выражения (a+)+$, который соответствует одной или нескольким последовательности одного или нескольких символов a в конце строки, подвергается чрезмерной обратной дорожке. Если возникает RegexMatchTimeoutException, в примере увеличивается время ожидания до максимального значения в три секунды. В противном случае он отказывается от попытки сопоставления шаблона.

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

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

Параметр matchTimeout указывает, как долго метод сопоставления шаблонов должен попытаться найти совпадение до истечения времени ожидания. Если совпадение не найдено в этом интервале времени, метод сопоставления шаблонов вызывает исключение RegexMatchTimeoutException. matchTimeout переопределяет любое значение времени ожидания по умолчанию, определенное для домена приложения, в котором создается объект Regex. Методы сопоставления шаблонов экземпляров, наблюдающие за интервалом времени ожидания matchTimeout, включают следующее:

• IsMatch

• Match

• Matches

• Replace

• Split

• Match.NextMatch

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

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

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

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

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

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

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

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

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

• обратное отслеживание в регулярных выражений
• элементы языка регулярных выражений