Regex Regex Regex Regex Constructors

Definition

Überlädt

Regex() Regex() Regex()

Initialisiert eine neue Instanz der Regex-Klasse.Initializes a new instance of the Regex class.

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

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck.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)

Initialisiert eine neue Instanz der Regex-Klasse mithilfe von serialisierten Daten.Initializes a new instance of the Regex class by using serialized data.

Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.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)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster und einen Wert ändern, der angibt, wie lange eine Musterabgleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt.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()

Initialisiert eine neue Instanz der Regex-Klasse.Initializes a new instance of the Regex class.

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

Hinweise

Beachten Sie, dass dieser Konstruktor ist geschützt. Es kann nur von abgeleiteten Klassen aufgerufen werden die Regex Klasse.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)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck.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)

Parameter

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

Beispiele

Im folgende Beispiel wird veranschaulicht, wie dieser Konstruktor verwendet einen regulären Ausdruck instanziiert werden, die mit einem beliebigen Wort übereinstimmt, die mit den Buchstaben beginnt "a" oder "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

Beachten Sie, dass das Muster des regulären Ausdrucks das Wort entsprechen, darf nicht "The" am Anfang des Texts, da es sich bei Vergleichen wird die Groß-/Kleinschreibung standardmäßig.Note that the regular expression pattern cannot match the word "The" at the beginning of the text, because comparisons are case-sensitive by default. Ein Beispiel für die Groß-/Kleinschreibung Vergleich, finden Sie unter den Regex(String, RegexOptions) Konstruktor.For an example of case-insensitive comparison, see the Regex(String, RegexOptions) constructor.

Hinweise

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter den reguläre Ausdrücke von .NET Framework und Sprachelemente für reguläre Ausdrücke – Kurzübersicht Themen.For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Aufrufen der Regex(String) Konstruktor entspricht dem Aufrufen der Regex(String, RegexOptions) Konstruktor mit einem Wert von None für die options Argument.Calling the Regex(String) constructor is equivalent to calling the Regex(String, RegexOptions) constructor with a value of None for the options argument.

Ein Regex -Objekt unveränderlich ist, was bedeutet, dass es nur für Muster von Match können Sie definieren verwendet werden, wenn Sie ihn erstellen.A Regex object is immutable, which means that it can be used only for the match pattern you define when you create it. Es kann jedoch oft ohne erneute Kompilierung verwendet.However, it can be used any number of times without being recompiled.

Dieser Konstruktor instanziiert das Objekt eines regulären Ausdrucks, der versucht, Groß-/ Kleinschreibung von alphabetischen Zeichen in definierten pattern.This constructor instantiates a regular expression object that attempts a case-sensitive match of any alphabetical characters defined in pattern. Verwenden Sie für eine Übereinstimmung Groß-/Kleinschreibung der Regex.Regex(String, RegexOptions) Konstruktor.For a case-insensitive match, use the Regex.Regex(String, RegexOptions) constructor.

Hinweise für Aufrufer

Dieser Konstruktor erstellt ein Regex Objekt, das den Standardtimeoutwert der Anwendungsdomäne verwendet, in dem es erstellt wird.This constructor creates a Regex object that uses the default time-out value of the application domain in which it is created. Wenn Sie ein Timeoutwert für die Anwendungsdomäne, nicht definiert wurde die Regex Objekt verwendet den Wert InfiniteMatchTimeout, die verhindert, dass bei der ein Timeout erfolgt. Die empfohlene Konstruktor zum Erstellen einer Regex Objekt ist Regex(String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen.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.

Siehe auch

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

Initialisiert eine neue Instanz der Regex-Klasse mithilfe von serialisierten Daten.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)

Parameter

info
SerializationInfo SerializationInfo SerializationInfo SerializationInfo

Das Objekt, das ein serialisiertes Muster und RegexOptions-Informationen enthält.The object that contains a serialized pattern and RegexOptions information.

context
StreamingContext StreamingContext StreamingContext StreamingContext

Das Ziel dieser Serialisierung.The destination for this serialization. (Dieser Parameter wird nicht verwendet, geben Sie null an.)(This parameter is not used; specify null.)

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

Das Muster, das diese info enthält, ist null.The pattern that info contains is null.

Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.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)

Parameter

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die den regulären Ausdruck ändern.A bitwise combination of the enumeration values that modify the regular expression.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

options enthält ein ungültiges Flag.options contains an invalid flag.

Beispiele

Im folgende Beispiel wird veranschaulicht, wie dieser Konstruktor verwendet einen regulären Ausdruck instanziiert werden, die mit einem beliebigen Wort übereinstimmt, die mit den Buchstaben beginnt "a" oder "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

Beachten Sie, dass die Match-Sammlung das Wort "The", die der Text beginnt enthält, da die options Parameter wurde die Groß-/Kleinschreibung Vergleiche definiert.Note that the match collection includes the word "The" that begins the text because the options parameter has defined case-insensitive comparisons.

Hinweise

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter den reguläre Ausdrücke von .NET Framework und Sprachelemente für reguläre Ausdrücke – Kurzübersicht Themen.For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Ein Regex -Objekt unveränderlich ist, was bedeutet, dass es nur für die Parameter für aktivitätsübereinstimmung können Sie definieren verwendet werden, bei der Erstellung.A Regex object is immutable, which means that it can be used only for the match parameters you define when you create it. Es kann jedoch oft ohne erneute Kompilierung verwendet.However, it can be used any number of times without being recompiled.

Hinweise für Aufrufer

Dieser Konstruktor erstellt ein Regex Objekt, das den Standardtimeoutwert der Anwendungsdomäne verwendet, in dem es erstellt wird.This constructor creates a Regex object that uses the default time-out value of the application domain in which it is created. Wenn Sie ein Timeoutwert für die Anwendungsdomäne, nicht definiert wurde die Regex Objekt verwendet den Wert InfiniteMatchTimeout, die verhindert, dass bei der ein Timeout erfolgt. Die empfohlene Konstruktor zum Erstellen einer Regex Objekt ist Regex(String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen.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.

Siehe auch

Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster und einen Wert ändern, der angibt, wie lange eine Musterabgleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt.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)

Parameter

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die den regulären Ausdruck ändern.A bitwise combination of the enumeration values that modify the regular expression.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

options ist kein gültiger RegexOptions-Wert.options is not a valid RegexOptions value.

- oder - -or- matchTimeout ist negativ, null oder größer als ca. 24 Tage.matchTimeout is negative, zero, or greater than approximately 24 days.

Beispiele

Im folgenden Beispiel wird die Regex(String, RegexOptions, TimeSpan) Konstruktor zum Instanziieren einer Regex Objekt mit einem Timeoutwert von einer Sekunde.The following example calls the Regex(String, RegexOptions, TimeSpan) constructor to instantiate a Regex object with a time-out value of one second. Das Muster des regulären Ausdrucks (a+)+$, das mit mindestens einer Sequenz von einem oder mehreren "a"-Zeichen am Ende einer Zeile übereinstimmt, unterliegt übermäßiger Rückverfolgung.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. Wenn eine RegexMatchTimeoutException wird ausgelöst, im Beispiel wird der Timeoutwert bis zum Höchstwert von drei Sekunden erhöht.If a RegexMatchTimeoutException is thrown, the example increases the time-out value up to the maximum value of three seconds. Andernfalls abgebrochen beim Versuch, die dem Muster entsprechen.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.

Hinweise

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter den reguläre Ausdrücke von .NET Framework und Sprachelemente für reguläre Ausdrücke – Kurzübersicht Themen.For more information about regular expressions, see the .NET Framework Regular Expressions and Regular Expression Language - Quick Reference topics.

Ein Regex -Objekt unveränderlich ist, was bedeutet, dass es, die Sie definieren, bei der Erstellung nur für Muster von Match verwendet werden kann.A Regex object is immutable, which means that it can be used only for the match pattern that you define when you create it. Es kann jedoch oft ohne erneute Kompilierung verwendet.However, it can be used any number of times without being recompiled.

Die matchTimeout Parameter gibt an, wie lange eine Mustervergleichs-Methode sollten versuchen, eine Übereinstimmung gefunden wird, bevor ein Timeout eintritt. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die musterübereinstimmungen-Methode eine RegexMatchTimeoutException Ausnahme.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 überschreibt alle Standard-Timeoutwert für die Anwendungsdomäne, in dem definiert die Regex Objekt erstellt wird.matchTimeout overrides any default time-out value defined for the application domain in which the Regex object is created. Die Instanz Mustervergleichs-Methoden, die beobachten der matchTimeout Timeoutintervall umfassen Folgendes:The instance pattern-matching methods that observe the matchTimeout time-out interval include the following:

Ein Timeoutintervall festlegen wird verhindert, dass reguläre Ausdrücke, die übermäßige rückverfolgung angezeigt werden, nicht mehr reagiert, wenn diese Eingaben verarbeiten, die in der Nähe von Übereinstimmungen enthält.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. Weitere Informationen finden Sie unter bewährte Methoden für reguläre Ausdrücke und Backtracking.For more information, see Best Practices for Regular Expressions and Backtracking. Um eine angemessene Timeoutintervall festzulegen, Faktoren Sie die folgenden:To set a reasonable time-out interval, consider the following factors:

  • Die Länge und Komplexität der Muster des regulären Ausdrucks.The length and complexity of the regular expression pattern. Längere und komplexere reguläre Ausdrücken benötigen mehr Zeit als kürzer und einfacher.Longer and more complex regular expressions require more time than shorter and simpler ones.

  • Der erwartete computerauslastung.The expected machine load. Die Verarbeitung dauert länger auf Systemen mit hoher CPU- und speicherauslastung.Processing takes more time on systems that have high CPU and memory utilization.

Hinweise für Aufrufer

Es wird empfohlen, Sie legen die matchTimeout Parameter auf einen geeigneten Wert, z. B. zwei Sekunden.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts werden, indem deaktiviert InfiniteMatchTimeout, die Engine für reguläre Ausdrücke bietet eine etwas bessere Leistung.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Allerdings sollten Sie Timeouts nur unter folgenden Bedingungen deaktivieren:However, you should disable time-outs only under the following conditions: – Wenn die Eingabe verarbeitet, die von einem regulären Ausdruck aus einer bekannten und vertrauenswürdigen Quelle stammt oder besteht aus statischen Text.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Dies schließt Text, der vom Benutzer eingegebene dynamisch wurde.This excludes text that has been dynamically input by users.

– Wenn Sie Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass er effizient verarbeitet übereinstimmt, nicht-Übereinstimmungen und Naher entspricht.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

– Wenn Muster für reguläre Ausdrücke keine Language-Elemente enthält, die bekannt sind, um eine übermäßige rückverfolgung bei der Verarbeitung einer Nahen Übereinstimmung zu verursachen.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Siehe auch

Gilt für: