Regex Konstruktoren

Referenz

Definition

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Initialisiert eine neue Instanz der Regex Klasse.

Überlädt

Regex()	Initialisiert eine neue Instanz der Regex Klasse.
Regex(String)	Initialisiert eine neue Instanz der Regex Klasse für den angegebenen regulären Ausdruck.
Regex(SerializationInfo, StreamingContext)	Veraltet. Initialisiert eine neue Instanz der Regex Klasse mithilfe serialisierter Daten.
Regex(String, RegexOptions)	Initialisiert eine neue Instanz der Regex Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster ändern.
Regex(String, RegexOptions, TimeSpan)	Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, mit denen das Muster geändert wird, und ein Wert, der angibt, wie lange eine Musterabgleichsmethode eine Übereinstimmung versuchen soll, bevor ein Zeitüberschreitung erfolgt.

Regex()

Quelle:: Regex.cs

Quelle:: Regex.cs

Quelle:: Regex.cs

Initialisiert eine neue Instanz der Regex Klasse.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Hinweise

Beachten Sie, dass dieser Konstruktor geschützt ist; sie kann nur von Klassen aufgerufen werden, die von der Regex Klasse abgeleitet werden.

Gilt für:

Regex(String)

Quelle:: Regex.cs

Quelle:: Regex.cs

Quelle:: Regex.cs

Initialisiert eine neue Instanz der Regex Klasse für den angegebenen regulären Ausdruck.

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

Das muster des regulären Ausdrucks, das übereinstimmen soll.

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

pattern ist null.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie diesen Konstruktor verwenden, um einen regulären Ausdruck zu instanziieren, der mit jedem Wort übereinstimmt, das mit den Buchstaben "a" oder "t" beginnt.

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 für reguläre Ausdrücke nicht mit dem Wort "The" am Anfang des Texts übereinstimmt, da bei Vergleichen standardmäßig die Groß-/Kleinschreibung beachtet wird. Ein Beispiel für einen Vergleich zwischen Groß- und Kleinschreibung finden Sie im Regex(String, RegexOptions)-Konstruktor.

Hinweise

Warnung

Wenn Sie System.Text.RegularExpressions verwenden, um nicht vertrauenswürdige Eingaben zu verarbeiten, übergeben Sie einen Timeoutwert, um zu verhindern, dass böswillige Benutzer einen Denial-of-Service-Angriffverursachen. Ein Timeoutwert gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Timeout ausgeht.

Der pattern-Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie in den themen .NET Regular Expressions und Regular Expression Language – Kurzübersicht Themen.

Das Aufrufen des Regex(String)-Konstruktors entspricht dem Aufrufen des Regex(String, RegexOptions)-Konstruktors mit dem Wert None für das Argument options.

Ein Regex-Objekt ist unveränderlich, was bedeutet, dass es nur für das Muster verwendet werden kann, das Sie beim Erstellen definieren. Es kann jedoch beliebig oft verwendet werden, ohne neu kompiliert zu werden.

Dieser Konstruktor instanziiert ein reguläres Ausdrucksobjekt, das eine Groß-/Kleinschreibung einer Übereinstimmung mit alphabetischen Zeichen versucht, die in patterndefiniert sind. Verwenden Sie für eine Übereinstimmung zwischen Groß- und Kleinschreibung den Regex.Regex(String, RegexOptions)-Konstruktor.

Hinweise für Aufrufer

Dieser Konstruktor erstellt ein Regex-Objekt, das den Standardtimeoutwert der Anwendungsdomäne verwendet, in der sie erstellt wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, verwendet das Regex-Objekt den Wert InfiniteMatchTimeout, wodurch verhindert wird, dass der Vorgang einen Timeout abhält. Der empfohlene Konstruktor zum Erstellen eines Regex-Objekts ist Regex(String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen können.

Weitere Informationen

Elemente der Sprache für reguläre Ausdrücke

Gilt für:

Regex(SerializationInfo, StreamingContext)

Quelle:: Regex.cs

Quelle:: Regex.cs

Quelle:: Regex.cs

Achtung

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

Initialisiert eine neue Instanz der Regex Klasse mithilfe serialisierter Daten.

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)

Parameter

info: SerializationInfo

Das Objekt, das ein serialisiertes Muster und RegexOptions Informationen enthält.

context: StreamingContext

Das Ziel für diese Serialisierung. (Dieser Parameter wird nicht verwendet; geben Sie nullan.)

Attribute: ObsoleteAttribute

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

Das muster, das info enthält, ist null.

ArgumentOutOfRangeException

info enthält ein ungültiges RegexOptions Flag.

Gilt für:

Regex(String, RegexOptions)

Quelle:: Regex.cs

Quelle:: Regex.cs

Quelle:: Regex.cs

Initialisiert eine neue Instanz der Regex Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster ändern.

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

Das muster des regulären Ausdrucks, das übereinstimmen soll.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die den regulären Ausdruck ändern.

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

pattern ist null.

ArgumentOutOfRangeException

options enthält ein ungültiges Kennzeichen.

Beispiele

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 Übereinstimmungsauflistung das Wort "The" enthält, das den Text beginnt, da für den parameter options vergleicht die Groß-/Kleinschreibung definiert wurde.

Hinweise

Warnung

Ein Regex-Objekt ist unveränderlich, was bedeutet, dass es nur für die Übereinstimmungsparameter verwendet werden kann, die Sie beim Erstellen definieren. Es kann jedoch beliebig oft verwendet werden, ohne neu kompiliert zu werden.

Hinweise für Aufrufer

Weitere Informationen

Elemente der Sprache für reguläre Ausdrücke

Gilt für:

Regex(String, RegexOptions, TimeSpan)

Quelle:: Regex.cs

Quelle:: Regex.cs

Quelle:: Regex.cs

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, mit denen das Muster geändert wird, und ein Wert, der angibt, wie lange eine Musterabgleichsmethode eine Übereinstimmung versuchen soll, bevor ein Zeitüberschreitung erfolgt.

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

Das muster des regulären Ausdrucks, das übereinstimmen soll.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die den regulären Ausdruck ändern.

matchTimeout: TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, um anzugeben, dass die Methode kein Timeout hat.

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

pattern ist null.

ArgumentOutOfRangeException

options ist kein gültiger RegexOptions Wert.

-oder-

matchTimeout ist negativ, null oder größer als etwa 24 Tage.

Beispiele

Im folgenden Beispiel wird der Regex(String, RegexOptions, TimeSpan)-Konstruktor aufgerufen, um ein Regex-Objekt mit einem Timeoutwert von einer Sekunde zu instanziieren. Das Muster des regulären Ausdrucks (a+)+$, das mindestens einer Sequenz eines oder mehrerer "a"-Zeichen am Ende einer Zeile entspricht, unterliegt übermäßigem Rücktracking. Wenn ein RegexMatchTimeoutException ausgelöst wird, erhöht das Beispiel den Timeoutwert auf den Maximalwert von drei Sekunden. Andernfalls wird der Versuch abgebrochen, dem Muster zu entsprechen.

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

Ein Regex-Objekt ist unveränderlich. Dies bedeutet, dass es nur für das Übereinstimmungsmuster verwendet werden kann, das Sie beim Erstellen definieren. Es kann jedoch beliebig oft verwendet werden, ohne neu kompiliert zu werden.

Der parameter matchTimeout gibt an, wie lange eine Musterabgleichsmethode versucht, eine Übereinstimmung zu finden, bevor ein Zeitüberschreitung erfolgt. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Musterabgleichsmethode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtimeoutwert, der für die Anwendungsdomäne definiert ist, in der das Regex-Objekt erstellt wird. Die Methoden für den Instanzmusterabgleich, die das matchTimeout Timeoutintervall beobachten, umfassen Folgendes:

Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßigem Rückverfolgungsvorgang basieren, nicht mehr reagieren, wenn sie Eingaben verarbeiten, die nahezu Übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Backtracking-. Um ein angemessenes Timeoutintervall festzulegen, berücksichtigen Sie die folgenden Faktoren:

Die Länge und Komplexität des Musters für reguläre Ausdrücke. Längere und komplexere reguläre Ausdrücke erfordern mehr Zeit als kürzere und einfachere Ausdrücke.
Die erwartete Computerlast. Die Verarbeitung benötigt mehr Zeit für Systeme mit hoher CPU- und Arbeitsspeicherauslastung.

Hinweise für Aufrufer

Es wird empfohlen, den parameter matchTimeout auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie InfiniteMatchTimeoutangeben, bietet das Modul für reguläre Ausdrücke etwas bessere Leistung. Sie sollten Timeouts jedoch nur unter den folgenden Bedingungen deaktivieren:

Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dadurch wird Text ausgeschlossen, der dynamisch von Benutzern eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und nahe Übereinstimmungen effizient verarbeitet.
Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen zu übermäßigem Rückverfolgungsverhalten bei der Verarbeitung einer Nahübereinstimmung führen.

Weitere Informationen

Gilt für:

Freigeben über

Regex Konstruktoren

Definition

Überlädt

Regex()

Hinweise

Gilt für:

Regex(String)

Parameter

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Regex(SerializationInfo, StreamingContext)

Parameter

Ausnahmen

Gilt für:

Regex(String, RegexOptions)

Parameter

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Regex(String, RegexOptions, TimeSpan)

Parameter

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Feedback

Zusätzliche Ressourcen