Regex Konstruktory

Definicja

Przestrzeń nazw:

System.Text.RegularExpressions

Zestaw:

System.Text.RegularExpressions.dll

Inicjuje nowe wystąpienie klasy Regex.

Przeciążenia

Regex()	Inicjuje nowe wystąpienie klasy Regex.
Regex(String)	Inicjuje Regex nowe wystąpienie klasy dla określonego wyrażenia regularnego.
Regex(SerializationInfo, StreamingContext)	Nieaktualne. Inicjuje Regex nowe wystąpienie klasy przy użyciu danych serializowanych.
Regex(String, RegexOptions)	Inicjuje Regex nowe wystąpienie klasy dla określonego wyrażenia regularnego z opcjami, które modyfikują wzorzec.
Regex(String, RegexOptions, TimeSpan)	Inicjuje nowe wystąpienie Regex klasy dla określonego wyrażenia regularnego z opcjami modyfikującymi wzorzec i wartością określającą, jak długo metoda dopasowania wzorca powinna podjąć próbę dopasowania przed upływem limitu czasu.

Regex()

Inicjuje nowe wystąpienie klasy Regex.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Uwagi

Należy pamiętać, że ten konstruktor jest chroniony; może być wywoływana tylko przez klasy pochodzące z Regex klasy.

Regex(String)

Inicjuje Regex nowe wystąpienie klasy dla określonego wyrażenia regularnego.

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)

Parametry

pattern

String

Wzorzec wyrażenia regularnego do dopasowania.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

pattern to null.

Przykłady

W poniższym przykładzie pokazano, jak za pomocą tego konstruktora utworzyć wystąpienie wyrażenia regularnego zgodnego z dowolnym wyrazem rozpoczynającym się literami "a" lub "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

Należy pamiętać, że wzorzec wyrażenia regularnego nie może być zgodny ze słowem "The" na początku tekstu, ponieważ porównania są domyślnie uwzględniane wielkość liter. Aby zapoznać się z przykładem porównania bez uwzględniania wielkości liter, zobacz Regex(String, RegexOptions) konstruktor.

Uwagi

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz tematy .NET Regular Expressions and Regular Expression Language — Quick Reference (Wyrażenia regularne platformy .NET i Język wyrażeń regularnych — szybki przewodnik).

Wywoływanie konstruktora Regex(String) jest równoważne wywołaniu konstruktora Regex(String, RegexOptions) z wartością None argumentu options .

Regex Obiekt jest niezmienny, co oznacza, że może być używany tylko dla wzorca dopasowania zdefiniowanego podczas jego tworzenia. Można go jednak używać dowolną liczbę razy bez ponownego skompilowania.

Ten konstruktor tworzy wystąpienie obiektu wyrażenia regularnego, który próbuje dopasować wielkość liter wszystkich znaków alfabetycznych zdefiniowanych w obiekcie pattern. W przypadku dopasowania bez uwzględniania wielkości liter użyj konstruktora Regex.Regex(String, RegexOptions) .

Uwagi dotyczące wywoływania

Ten konstruktor tworzy Regex obiekt, który używa domyślnej wartości limitu czasu domeny aplikacji, w której jest tworzona. Jeśli dla domeny aplikacji nie zdefiniowano wartości limitu czasu, Regex obiekt używa wartości InfiniteMatchTimeout, co uniemożliwia przekroczenie limitu czasu operacji. Zalecanym konstruktorem Regex do tworzenia obiektu jest Regex(String, RegexOptions, TimeSpan), który umożliwia ustawienie interwału limitu czasu.

Zobacz też

• Elementy języka wyrażeń regularnych

Regex(SerializationInfo, StreamingContext)

Przestroga

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Inicjuje Regex nowe wystąpienie klasy przy użyciu danych serializowanych.

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

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

Parametry

info

SerializationInfo

Obiekt zawierający serializowany wzorzec i RegexOptions informacje.

context

StreamingContext

Lokalizacja docelowa tej serializacji. (Ten parametr nie jest używany; określ wartość null.)

Atrybuty

ObsoleteAttribute

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

Wzorzec, który zawiera, info to null.

ArgumentOutOfRangeException

info zawiera nieprawidłową RegexOptions flagę.

Regex(String, RegexOptions)

Inicjuje Regex nowe wystąpienie klasy dla określonego wyrażenia regularnego z opcjami, które modyfikują wzorzec.

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)

Parametry

pattern

String

Wzorzec wyrażenia regularnego do dopasowania.

options

RegexOptions

Bitowa kombinacja wartości wyliczenia, które modyfikują wyrażenie regularne.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

pattern to null.

ArgumentOutOfRangeException

options zawiera nieprawidłową flagę.

Przykłady

W poniższym przykładzie pokazano, jak za pomocą tego konstruktora utworzyć wystąpienie wyrażenia regularnego zgodnego z dowolnym wyrazem rozpoczynającym się literami "a" lub "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

Należy pamiętać, że kolekcja dopasowań zawiera słowo "The", które rozpoczyna tekst, ponieważ options parametr ma zdefiniowane porównania bez uwzględniania wielkości liter.

Uwagi

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz tematy .NET Regular Expressions and Regular Expression Language — Quick Reference (Wyrażenia regularne platformy .NET i Język wyrażeń regularnych — szybki przewodnik).

Regex Obiekt jest niezmienny, co oznacza, że może być używany tylko dla parametrów dopasowania zdefiniowanych podczas jego tworzenia. Można go jednak używać dowolną liczbę razy bez ponownego skompilowania.

Uwagi dotyczące wywoływania

Ten konstruktor tworzy Regex obiekt, który używa domyślnej wartości limitu czasu domeny aplikacji, w której jest tworzona. Jeśli dla domeny aplikacji nie zdefiniowano wartości limitu czasu, Regex obiekt używa wartości InfiniteMatchTimeout, co uniemożliwia przekroczenie limitu czasu operacji. Zalecanym konstruktorem Regex do tworzenia obiektu jest Regex(String, RegexOptions, TimeSpan), który umożliwia ustawienie interwału limitu czasu.

Zobacz też

• Elementy języka wyrażeń regularnych

Regex(String, RegexOptions, TimeSpan)

Inicjuje nowe wystąpienie Regex klasy dla określonego wyrażenia regularnego z opcjami modyfikującymi wzorzec i wartością określającą, jak długo metoda dopasowania wzorca powinna podjąć próbę dopasowania przed upływem limitu czasu.

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)

Parametry

pattern

String

Wzorzec wyrażenia regularnego do dopasowania.

options

RegexOptions

Bitowa kombinacja wartości wyliczenia, które modyfikują wyrażenie regularne.

matchTimeout

TimeSpan

Interwał limitu czasu lub InfiniteMatchTimeout wskazujący, że metoda nie powinna upłynął limit czasu.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

pattern to null.

ArgumentOutOfRangeException

options jest nieprawidłową RegexOptions wartością.

-lub-

matchTimeout jest ujemna, zero lub większa niż około 24 dni.

Przykłady

Poniższy przykład wywołuje konstruktora w Regex(String, RegexOptions, TimeSpan) celu utworzenia wystąpienia Regex obiektu z wartością limitu czasu jednej sekundy. Wzorzec (a+)+$wyrażenia regularnego, który pasuje do co najmniej jednej sekwencji co najmniej jednego znaku "a" na końcu wiersza, podlega nadmiernemu wycofywaniu. RegexMatchTimeoutException Jeśli wartość jest zgłaszana, przykład zwiększa wartość limitu czasu do maksymalnej wartości wynoszącej trzy sekundy. W przeciwnym razie porzuca próbę dopasowania wzorca.

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.

Uwagi

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz tematy .NET Regular Expressions and Regular Expression Language — Quick Reference (Wyrażenia regularne platformy .NET i Język wyrażeń regularnych — szybki przewodnik).

Regex Obiekt jest niezmienny, co oznacza, że może być używany tylko dla wzorca dopasowania zdefiniowanego podczas jego tworzenia. Można go jednak używać dowolną liczbę razy bez ponownego skompilowania.

Parametr matchTimeout określa, jak długo metoda dopasowywania wzorca powinna spróbować znaleźć dopasowanie przed upływem limitu czasu. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda dopasowywania wzorca zgłasza RegexMatchTimeoutException wyjątek. matchTimeout zastępuje dowolną domyślną wartość limitu czasu zdefiniowaną dla domeny aplikacji, w której Regex jest tworzony obiekt. Metody dopasowywania wzorca wystąpienia, które obserwują matchTimeout interwał limitu czasu, obejmują następujące elementy:

• IsMatch

• Match

• Matches

• Replace

• Split

• Match.NextMatch

Ustawienie interwału limitu czasu zapobiega wyrażeniom regularnym, które polegają na nadmiernej wycofywaniu, aby przestać odpowiadać podczas przetwarzania danych wejściowych zawierających niemal dopasowania. Aby uzyskać więcej informacji, zobacz Najlepsze rozwiązania dotyczące wyrażeń regularnych i wycofywania. Aby ustawić rozsądny interwał limitu czasu, rozważ następujące czynniki:

• Długość i złożoność wzorca wyrażenia regularnego. Dłuższe i bardziej złożone wyrażenia regularne wymagają więcej czasu niż krótsze i prostsze.

• Oczekiwane obciążenie maszyny. Przetwarzanie zajmuje więcej czasu w systemach, które mają wysokie wykorzystanie procesora CPU i pamięci.

Uwagi dotyczące wywoływania

Zalecamy ustawienie parametru matchTimeout na odpowiednią wartość, taką jak dwie sekundy. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeoutwartość , aparat wyrażeń regularnych zapewnia nieco lepszą wydajność. Należy jednak wyłączyć limity czasu tylko w następujących warunkach:

• Gdy dane wejściowe przetwarzane przez wyrażenie regularne pochodzą ze znanego i zaufanego źródła lub składają się z tekstu statycznego. Wyklucza to tekst, który został dynamicznie wprowadzany przez użytkowników.

• Gdy wzorzec wyrażenia regularnego został dokładnie przetestowany, aby upewnić się, że efektywnie obsługuje dopasowania, niezgodne i zbliżające się dopasowania.

• Gdy wzorzec wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane do nadmiernego wycofywania podczas przetwarzania niemal zgodnego.

Zobacz też

• Śledzenie wsteczne w wyrażeniach regularnych
• Elementy języka wyrażeń regularnych