Regex.Match Methode

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Parameter

Gibt zurück

Ein Objekt, das Informationen zur Übereinstimmung enthält.

Ausnahmen

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der Wörtern entspricht, die mit dem Buchstaben "a" beginnen. Es verwendet die RegexOptions.IgnoreCase Option, um sicherzustellen, dass der reguläre Ausdruck Wörter sucht, die mit einem Großbuchstaben "a" und einem Kleinbuchstaben "a" beginnen.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        public static void Main()
        {
            string pattern = @"\ba\w*\b";
            string input = "An extraordinary day dawns with each new day.";
            Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            if (m.Success)
                Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
        }
    }
}

// The example displays the following output:
//        Found 'An' at position 0.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

Das Muster für reguläre Ausdrücke \ba\w*\b wird entsprechend der folgenden Tabelle interpretiert:

Hinweise

Die Match(String, String, RegexOptions) -Methode gibt die erste Teilzeichenfolge zurück, die mit einem Muster für reguläre Ausdrücke in einer Eingabezeichenfolge übereinstimmt. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter Regular Expression Language – Schnellreferenz.

Die statische Match(String, String, RegexOptions) Methode entspricht dem Erstellen eines Regex Objekts mit dem Regex(String, RegexOptions) Konstruktor und dem Aufrufen der instance-MethodeMatch(String).

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 unter .NET Regular Expressions and Regular Expression Language – Kurzreferenz.

Sie können ermitteln, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem Sie den Wert der -Eigenschaft des zurückgegebenen Match Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Match Objekts die Teilzeichenfolge ausinput, die dem Muster für reguläre Ausdrücke Value entspricht. Wenn keine Übereinstimmung gefunden wird, ist String.Emptyder Wert .

Diese Methode gibt die erste Teilzeichenfolge zurück, die in input gefunden wurde und mit dem Muster für reguläre Ausdrücke übereinstimmt. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie die -Methode des NextMatch zurückgegebenen Match Objekts wiederholt aufrufen. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, indem Sie die Regex.Matches(String, String, RegexOptions) -Methode aufrufen.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Abgleichsvorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Bei dieser Methode tritt ein Timeout nach einem Intervall auf, das dem Standardtimeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der ein Timeout der Methode verhindert. Die empfohlene statische Methode zum Abrufen einer Musterüberstimmung ist Match(String, String), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

• NextMatch()
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);

public System.Text.RegularExpressions.Match Match (string input);

member this.Match : string -> System.Text.RegularExpressions.Match

Public Function Match (input As String) As Match

Parameter

Gibt zurück

Ein Objekt, das Informationen zur Übereinstimmung enthält.

Ausnahmen

Beispiele

Im folgenden Beispiel werden Übereinstimmungen des Musters für reguläre Ausdrücke in einer Zeichenfolge gesucht und dann die übereinstimmend zugeordneten Gruppen, Erfassungs- und Erfassungspositionen aufgelistet.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

using System;
using System.Text.RegularExpressions;

class Example
{
   static void Main()
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);

      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success)
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++)
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++)
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Das Muster (\w+)\s+(car) für reguläre Ausdrücke stimmt mit vorkommenden Vorkommen des Worts "car" zusammen mit dem Wort überein, das ihm vorangestellt ist. Sie wird wie in der folgenden Tabelle dargestellt interpretiert.

Hinweise

Die Match(String) -Methode gibt die erste Teilzeichenfolge zurück, die mit einem Muster für reguläre Ausdrücke in einer Eingabezeichenfolge übereinstimmt. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter Regular Expression Language – Schnellreferenz.

Sie können ermitteln, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem Sie den Wert der -Eigenschaft des zurückgegebenen Match Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Match Objekts die Teilzeichenfolge ausinput, die dem Muster für reguläre Ausdrücke Value entspricht. Wenn keine Übereinstimmung gefunden wird, ist String.Emptyder Wert .

Diese Methode gibt die erste Teilzeichenfolge in zurück input , die mit dem Muster für reguläre Ausdrücke übereinstimmt. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie die -Methode des Match.NextMatch zurückgegebenen Match Objekts wiederholt aufrufen. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, indem Sie die Regex.Matches(String) -Methode aufrufen.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Abgleichsvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird. Wenn im Konstruktoraufruf oder in den Eigenschaften der Regex Anwendungsdomäne kein Timeout definiert ist oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Weitere Informationen

• NextMatch()
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);

public System.Text.RegularExpressions.Match Match (string input, int startat);

member this.Match : string * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, startat As Integer) As Match

Parameter

Gibt zurück

Ein Objekt, das Informationen zur Übereinstimmung enthält.

Ausnahmen

Hinweise

Weitere Informationen zu dieser API finden Sie unter Ergänzende API-Hinweise für Regex.Match.

Weitere Informationen

• NextMatch()
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.Match Match (string input, string pattern);

static member Match : string * string -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String) As Match

Parameter

Gibt zurück

Ein Objekt, das Informationen zur Übereinstimmung enthält.

Ausnahmen

Beispiele

Im folgenden Beispiel wird die Match(String, String) -Methode aufgerufen, um das erste Wort zu finden, das mindestens ein z Zeichen enthält. Anschließend wird die Match.NextMatch -Methode aufgerufen, um weitere Übereinstimmungen zu finden.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example
    {
        public static void Main()
        {
            string input = "ablaze beagle choral dozen elementary fanatic " +
                           "glaze hunger inept jazz kitchen lemon minus " +
                           "night optical pizza quiz restoration stamina " +
                           "train unrest vertical whiz xray yellow zealous";
            string pattern = @"\b\w*z+\w*\b";
            Match m = Regex.Match(input, pattern);
            while (m.Success)
            {
                Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
                m = m.NextMatch();
            }
        }
    }
}

// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

Das Muster für reguläre Ausdrücke \b\w*z+\w*\b wird entsprechend der folgenden Tabelle interpretiert:

Hinweise

Die Match(String, String) -Methode gibt die erste Teilzeichenfolge zurück, die mit einem Muster für reguläre Ausdrücke in einer Eingabezeichenfolge übereinstimmt. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter Regular Expression Language – Schnellreferenz.

Die statische Match(String, String) Methode entspricht dem Erstellen eines Regex Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Aufrufen der instance-MethodeMatch(String). In diesem Fall speichert die Engine für reguläre Ausdrücke das Muster für reguläre Ausdrücke zwischen.

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 unter .NET Regular Expressions and Regular Expression Language – Kurzreferenz.

Sie können ermitteln, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem Sie den Wert der -Eigenschaft des zurückgegebenen Match Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Match Objekts die Teilzeichenfolge ausinput, die dem Muster für reguläre Ausdrücke Value entspricht. Wenn keine Übereinstimmung gefunden wird, ist String.Emptyder Wert .

Diese Methode gibt die erste Teilzeichenfolge in zurück input , die mit dem Muster für reguläre Ausdrücke übereinstimmt. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie die -Methode des Match.NextMatch zurückgegebenen Match Objekts wiederholt aufrufen. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, indem Sie die Regex.Matches(String, String) -Methode aufrufen.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Abgleichsvorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Bei dieser Methode tritt ein Timeout nach einem Intervall auf, das dem Standardtimeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der ein Timeout der Methode verhindert. Die empfohlene statische Methode zum Abrufen einer Musterüberstimmung ist Match(String, String), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

• NextMatch()
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);

public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);

member this.Match : string * int * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Parameter

Gibt zurück

Ein Objekt, das Informationen zur Übereinstimmung enthält.

Ausnahmen

Hinweise

Die Match(String, Int32, Int32) -Methode gibt die erste Teilzeichenfolge zurück, die mit einem Muster für reguläre Ausdrücke in einem Teil einer Eingabezeichenfolge übereinstimmt. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter Regular Expression Language – Schnellreferenz.

Das Muster für reguläre Ausdrücke, nach dem die Match(String, Int32, Int32) Methode sucht, wird durch den Aufruf eines der Regex Klassenkonstruktoren definiert. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Regular Expression Language – Schnellreferenz.

Die Match(String, Int32, Int32) -Methode durchsucht den durch die beginning Parameter und length definierten Teil von input nach dem Muster für reguläre Ausdrücke. beginning definiert immer den Index des am weitesten links stehenden Zeichens, das in die Suche aufgenommen werden soll, und length definiert die maximale Anzahl der zu durchsuchenden Zeichen. Zusammen definieren sie den Bereich der Suche. Das Verhalten ist genau so, als ob effektiv inputinput.Substring(beginning, length)wäre, mit der Ausnahme, dass der Index einer übereinstimmung relativ zum Anfang von inputgezählt wird. Dies bedeutet, dass sich alle Anker oder Assertionen mit 0er Breite am Anfang oder Ende des Musters so verhalten, als ob außerhalb dieses Bereichs keine input vorhanden wäre. Beispielsweise werden die Anker ^, \Gund \A bei beginning und $\z und erfüllt beginning + length - 1.

Wenn die Suche von links nach rechts fortgesetzt wird (Standard), sucht die Engine für reguläre Ausdrücke vom Zeichen am Index beginning zum Zeichen am Index beginning + length - 1. Wenn die Engine für reguläre Ausdrücke mithilfe der RegexOptions.RightToLeft Option instanziiert wurde, sodass die Suche von rechts nach links fortgesetzt wird, sucht die Engine für reguläre Ausdrücke vom Zeichen am Index beginning + length - 1 zum Zeichen am Index beginning.

Diese Methode gibt die erste Übereinstimmung zurück, die sie innerhalb dieses Bereichs findet. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie die -Methode des Match.NextMatch zurückgegebenen Match Objekts wiederholt aufrufen.

Sie können ermitteln, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem Sie den Wert der -Eigenschaft des zurückgegebenen Match Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Match Objekts die Teilzeichenfolge ausinput, die dem Muster für reguläre Ausdrücke Value entspricht. Wenn keine Übereinstimmung gefunden wird, ist String.Emptyder Wert .

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Abgleichsvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors keinen Timeoutwert festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird. Wenn im Konstruktoraufruf oder in den Eigenschaften der Regex Anwendungsdomäne kein Timeout definiert ist oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Weitere Informationen

• NextMatch()
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Parameter

Gibt zurück

Ein Objekt, das Informationen zur Übereinstimmung enthält.

Ausnahmen

Hinweise

Die Match(String, String, RegexOptions, TimeSpan) -Methode gibt die erste Teilzeichenfolge zurück, die mit einem Muster für reguläre Ausdrücke in einer Eingabezeichenfolge übereinstimmt. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter Regular Expression Language – Schnellreferenz.

Die statische Match(String, String, RegexOptions, TimeSpan) Methode entspricht dem Erstellen eines Regex Objekts mit dem Regex(String, RegexOptions, TimeSpan) Konstruktor und dem Aufrufen der instance-MethodeMatch(String).

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 unter .NET Regular Expressions and Regular Expression Language – Kurzreferenz.

Sie können ermitteln, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem Sie den Wert der -Eigenschaft des zurückgegebenen Match Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Match Objekts die Teilzeichenfolge ausinput, die dem Muster für reguläre Ausdrücke Value entspricht. Wenn keine Übereinstimmung gefunden wird, ist String.Emptyder Wert .

Diese Methode gibt die erste Teilzeichenfolge zurück, die in input gefunden wurde und mit dem Muster für reguläre Ausdrücke übereinstimmt. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie die -Methode des NextMatch zurückgegebenen Match Objekts wiederholt aufrufen. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, indem Sie die Regex.Matches(String, String, RegexOptions) -Methode aufrufen.

Der matchTimeout Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Zeitüberschreitung vorliegt. 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. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine Ausnahme aus RegexMatchTimeoutException . matchTimeout überschreibt jeden Standardtimeoutwert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

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

• Sprachelemente für reguläre Ausdrücke – Kurzübersicht