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 von serialisierten Daten.
Regex(String, RegexOptions)	Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.
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 Mustervergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt.

Regex()

Source:: Regex.cs

Source:: Regex.cs

Source:: 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 sind.

Gilt für:

Regex(String)

Source:: Regex.cs

Source:: Regex.cs

Source:: 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 eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

pattern ist null.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie dieser Konstruktor verwendet wird, um einen regulären Ausdruck zu instanziieren, der mit einem beliebigen 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 übereinstimmen kann, da bei Vergleichen standardmäßig die Groß-/Kleinschreibung beachtet wird. Ein Beispiel für einen Vergleich ohne Beachtung der Groß-/Kleinschreibung finden Sie im Regex(String, RegexOptions) Konstruktor.

Hinweise

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

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

Ein Regex Objekt ist unveränderlich, was 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.

Dieser Konstruktor instanziiert ein Objekt mit regulären Ausdrücken, das versucht, eine Übereinstimmung mit allen in patterndefinierten alphabetischen Zeichen zu berücksichtigen. Verwenden Sie für eine Übereinstimmung ohne Berücksichtigung der Groß-/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 er erstellt wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, verwendet das Regex Objekt den Wert InfiniteMatchTimeout, wodurch ein Timeout für den Vorgang verhindert wird. Der empfohlene Konstruktor zum Erstellen eines Regex Objekts ist Regex(String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen können.

Weitere Informationen

Sprachelemente für reguläre Ausdrücke

Gilt für:

Regex(SerializationInfo, StreamingContext)

Source:: Regex.cs

Source:: Regex.cs

Source:: 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 von serialisierten 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 dieser Serialisierung. (Dieser Parameter wird nicht verwendet, geben Sie null an.)

Attribute: ObsoleteAttribute

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

Das Muster, das diese info enthält, ist null.

ArgumentOutOfRangeException

info enthält ein ungültiges RegexOptions-Flag.

Gilt für:

Regex(String, RegexOptions)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.

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 eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options: RegexOptions

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

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

pattern ist null.

ArgumentOutOfRangeException

options enthält ein ungültiges Flag.

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 der Parameter Vergleiche ohne Berücksichtigung der options Groß-/Kleinschreibung definiert hat.

Hinweise

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

Sprachelemente für reguläre Ausdrücke

Gilt für:

Regex(String, RegexOptions, TimeSpan)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

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 Mustervergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt.

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 eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options: RegexOptions

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

matchTimeout: TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.

Ausnahmen

ArgumentException

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

ArgumentNullException

pattern ist null.

ArgumentOutOfRangeException

options ist kein gültiger RegexOptions-Wert.

- oder -

matchTimeout ist negativ, null oder größer als ca. 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 mit mindestens einer Sequenz von einem oder mehreren "a"-Zeichen am Ende einer Zeile übereinstimmt, unterliegt übermäßiger Rückverfolgung. Wenn ein RegexMatchTimeoutException ausgelöst wird, erhöht das Beispiel den Timeoutwert auf den maximalen Wert von drei Sekunden. Andernfalls wird der Versuch aufgegeben, 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

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

Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung 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 Rückverfolgung. Berücksichtigen Sie die folgenden Faktoren, um ein angemessenes Timeoutintervall festzulegen:

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 nimmt bei Systemen mit hoher CPU- und Arbeitsspeicherauslastung mehr Zeit in Anspruch.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet die Engine für reguläre Ausdrücke eine 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. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass Übereinstimmungen, Nicht-Übereinstimmungen und Fast-Übereinstimmungen effizient verarbeitet werden.
Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, von denen bekannt ist, dass sie bei der Verarbeitung einer nahen Übereinstimmung eine übermäßige Rückverfolgung verursachen.

Weitere Informationen

Gilt für:

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