Regex.Match Methode

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.

Durchsucht eine Eingabezeichenfolge nach einer Teilzeichenfolge, die einem Muster für reguläre Ausdrücke entspricht, und gibt das erste Vorkommen als einzelnes Match -Objekt zurück.

Überlädt

Match(String)	Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des im Regex-Konstruktor angegebenen regulären Ausdrucks.
Match(String, Int32)	Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks, beginnend mit der angegebenen Anfangsposition in der Zeichenfolge.
Match(String, String)	Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.
Match(String, Int32, Int32)	Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks, beginnend mit der angegebenen Anfangsposition und nur die angegebene Anzahl von Zeichen.
Match(String, String, RegexOptions)	Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks mithilfe der angegebenen Abgleichsoptionen.
Match(String, String, RegexOptions, TimeSpan)	Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks unter Verwendung der angegebenen Abgleichsoptionen und des Timeoutintervalls.

Match(String)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des im Regex-Konstruktor angegebenen regulären Ausdrucks.

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

input: String

Die Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

Gibt zurück

Match

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

Ausnahmen

ArgumentNullException

input ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel werden Übereinstimmungen mit regulären Ausdrücken in einer Zeichenfolge gefunden. Anschließend werden die übereinstimmende 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 für reguläre Ausdrücke (\w+)\s+(car) entspricht Vorkommen des Worts "Auto" zusammen mit dem vorangestellten Wort. Sie wird wie in der folgenden Tabelle dargestellt interpretiert.

Muster	Beschreibung
`(\w+)`	Entspricht einem oder mehreren Wortzeichen. Dies ist die erste Erfassungsgruppe.
`\s+`	Entspricht einem oder mehreren Leerzeichen.
(Auto)	Stimmen Sie mit der Literalzeichenfolge "car" überein. Dies ist die zweite Erfassungsgruppe.

Hinweise

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

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

Diese Methode gibt die erste Teilzeichenfolge in input zurück, die dem Muster für reguläre Ausdrücke entspricht. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie wiederholt die Match.NextMatch Methode des zurückgegebenen Match Objekts 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 durch den 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 kein Timeout im Regex-Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Weitere Informationen

Gilt für:

Match(String, Int32)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks, beginnend mit der angegebenen Anfangsposition in der Zeichenfolge.

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

input: String

Die Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

startat: Int32

Die nullbasierte Zeichenposition, an der die Suche gestartet werden soll.

Gibt zurück

Match

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

Ausnahmen

ArgumentNullException

input ist null.

ArgumentOutOfRangeException

startat ist kleiner als null oder größer als die Länge von input.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Hinweise

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

Weitere Informationen

Gilt für:

Match(String, String)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.

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

input: String

Die Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

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

Gibt zurück

Match

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

Ausnahmen

ArgumentException

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

ArgumentNullException

input oder pattern ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel wird die Match(String, String)-Methode aufgerufen, um das erste Wort zu finden, das mindestens ein z Zeichen enthält, und ruft dann die Match.NextMatch-Methode auf, 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 wie in der folgenden Tabelle dargestellt interpretiert.

Muster	Beschreibung
`\b`	Beginnen Sie die Übereinstimmung an einer Wortgrenze.
`\w*`	0, ein oder mehrere Wortzeichen entsprechen.
`z+`	Entspricht einem oder mehreren Vorkommen des `z` Zeichens.
`\w*`	0, ein oder mehrere Wortzeichen entsprechen.
`\b`	Beenden Sie die Übereinstimmung an einer Wortgrenze.

Hinweise

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

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 Instanz Match(String) Methode. In diesem Fall speichert das Reguläre Ausdrucksmodul das Muster für reguläre Ausdrücke zwischen.

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 unter .NET Regular Expressions und Regular Expression Language – Kurzübersicht.

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 kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, 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, wodurch verhindert wird, dass die Methode einen Timeoutzeitpunkt erhält. Die empfohlene statische Methode zum Abrufen einer Mustervergleichung ist Match(String, String), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

Gilt für:

Match(String, Int32, Int32)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks, beginnend mit der angegebenen Anfangsposition und nur die angegebene Anzahl von Zeichen.

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

input: String

Die Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

beginning: Int32

Die nullbasierte Zeichenposition in der Eingabezeichenfolge, die die am weitesten links zu durchsuchende Position definiert.

length: Int32

Die Anzahl der Zeichen in der Teilzeichenfolge, die in die Suche eingeschlossen werden soll.

Gibt zurück

Match

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

Ausnahmen

ArgumentNullException

input ist null.

ArgumentOutOfRangeException

beginning ist kleiner als null oder größer als die Länge von input.

-oder-

length ist kleiner als null oder größer als die Länge von input.

-oder-

beginning + length -1 identifiziert eine Position außerhalb des Bereichs input.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Hinweise

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

Das Muster für reguläre Ausdrücke, nach dem die Match(String, Int32, Int32)-Methode durchsucht wird, 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 Sprache für reguläre Ausdrücke – Kurzübersicht.

Die Match(String, Int32, Int32)-Methode durchsucht den Teil input, der durch die beginning und length Parameter für das Muster für reguläre Ausdrücke definiert wurde. beginning definiert immer den Index des äußerst linken 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 die input effektiv input.Substring(beginning, length)war, außer dass der Index einer Übereinstimmung relativ zum Anfang der inputgezählt wird. Dies bedeutet, dass sich alle Anker- oder Nullbreiten-Assertionen am Anfang oder Ende des Musters verhalten, als ob außerhalb dieses Bereichs keine input vorhanden ist. Beispielsweise werden die Anker ^, \Gund \A bei beginning und $ und \z bei beginning + length - 1zufrieden sein.

Wenn die Suche von links nach rechts fortgesetzt wird (Standardeinstellung), durchsucht das Reguläre Ausdrucksmodul von dem Zeichen im Index beginning zum Zeichen im Index beginning + length - 1. Wenn das Modul für reguläre Ausdrücke mithilfe der Option RegexOptions.RightToLeft instanziiert wurde, sodass die Suche von rechts nach links verläuft, durchsucht das Reguläre Ausdrucksmodul vom Zeichen am Index beginning + length - 1 zum Zeichen bei Index beginning.

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

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Abgleichsvorgangs das durch den 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 ist, in der das Regex-Objekt erstellt wird. Wenn kein Timeout im Regex-Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Weitere Informationen

Gilt für:

Match(String, String, RegexOptions)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks mithilfe der angegebenen Abgleichsoptionen.

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

input: String

Die Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

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

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für den Abgleich bereitstellen.

Gibt zurück

Match

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

Ausnahmen

ArgumentException

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

ArgumentNullException

input oder pattern ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination aus RegexOptions Werten.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der wörtern entspricht, die mit dem Buchstaben "a" beginnen. Sie verwendet die Option RegexOptions.IgnoreCase, um sicherzustellen, dass der reguläre Ausdruck Wörter findet, 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 wie in der folgenden Tabelle dargestellt interpretiert.

Muster	Beschreibung
`\b`	Beginnen Sie die Übereinstimmung an einer Wortgrenze.
`a`	Entspricht dem Zeichen "a".
`\w*`	0, ein oder mehrere Wortzeichen entsprechen.
`\b`	Beenden Sie die Übereinstimmung an einer Wortgrenze.

Hinweise

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

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

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

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Match(String, String, RegexOptions, TimeSpan)

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Quelle:: Regex.Match.cs

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks unter Verwendung der angegebenen Abgleichsoptionen und des Timeoutintervalls.

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

input: String

Die Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

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

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für den Abgleich bereitstellen.

matchTimeout: TimeSpan

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

Gibt zurück

Match

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

Ausnahmen

ArgumentException

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

ArgumentNullException

input oder pattern ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination aus RegexOptions Werten.

-oder-

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

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Hinweise

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

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 Instanz Match(String) Methode.

Diese Methode gibt die erste Teilzeichenfolge in input zurück, die dem Muster für reguläre Ausdrücke entspricht. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie wiederholt die NextMatch Methode des zurückgegebenen Match Objekts 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 versucht werden soll, eine Übereinstimmung zu finden, bevor es zu einem Zeitüberschreitung kommt. 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-. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. 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 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

Sprache für reguläre Ausdrücke – Kurzübersicht

Gilt für:

Freigeben über

Regex.Match Methode

Definition

Überlädt

Match(String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Match(String, Int32)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Match(String, String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Match(String, Int32, Int32)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Match(String, String, RegexOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Match(String, String, RegexOptions, TimeSpan)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen