Regex.Match Methode

Definition

Durchsucht eine Eingabezeichenfolge nach einer Teilzeichenfolge, die mit einem Muster eines regulären Ausdrucks übereinstimmt, und gibt das erste Vorkommen als einzelnes Match-Objekt zurück.

Überlädt

Match(String, String, RegexOptions, TimeSpan)

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

Match(String, Int32, Int32)

Sucht beginnend an der angegebenen Anfangsposition in der Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks und sucht nur nach der angegebenen Anzahl von Zeichen.

Match(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.

Match(String, Int32)

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

Match(String)

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

Match(String, String)

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

Match(String, String, RegexOptions, TimeSpan)

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

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 nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

matchTimeout
TimeSpan

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

Gibt zurück

Match

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

Ausnahmen

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

input oder pattern ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

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

Es ist ein Timeout 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 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 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 Match(String) Instanzmethode.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und 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 -Eigenschaft des Match zurückgegebenen Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die Match -Eigenschaft des zurückgegebenen Objekts Value die Teilzeichenfolge aus input , die dem Muster des regulären Ausdrucks entspricht. Wenn keine Übereinstimmung gefunden wird, lautet der Wert String.Empty .

Diese Methode gibt die erste Teilzeichenfolge in input zurück, die dem Muster des regulären Ausdrucks entspricht. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie wiederholt die Match -Methode des zurückgegebenen Objekts NextMatch 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 Zeitauslauf erfolgt. Das Festlegen eines Time out-Intervalls 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 RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtime out-Wert, 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 Time outs deaktivieren, indem Sie InfiniteMatchTimeout angeben, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Time outs sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden: – 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 von Benutzern dynamisch eingegeben wurde.

– Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass übereinstimmungen, nicht übereinstimmende und nahezu übereinstimmende Übereinstimmungen effizient verarbeitet werden.

– Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine Nahezu-Übereinstimmung verarbeitet wird.

Siehe auch

Gilt für

Match(String, Int32, Int32)

Sucht beginnend an der angegebenen Anfangsposition in der Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks und sucht nur nach der angegebenen 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 nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

beginning
Int32

Die nullbasierte Zeichenposition in der Eingabezeichenfolge, die die am weitesten links stehende Position definiert, die gesucht werden soll.

length
Int32

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

Gibt zurück

Match

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

Ausnahmen

input ist null.

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

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

- oder - beginning+length-1 gibt eine Position außerhalb des Bereichs von input an.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

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

Das Muster für reguläre Ausdrücke, nach dem die Methode sucht, wird durch den Aufruf Match(String, Int32, Int32) 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 – Kurzreferenz.

Die Match(String, Int32, Int32) -Methode durchsucht den Teil von input , der durch die Parameter und definiert beginning length wird, nach dem Muster für reguläre Ausdrücke. beginning definiert immer den Index des äußerst linken Zeichens, das in die Suche aufgenommen werden soll, und definiert die maximale Anzahl der zu length suchden Zeichen. Zusammen definieren sie den Bereich der Suche. Wenn die Suche von links nach rechts (Standardeinstellung) fortgesetzt wird, sucht die Engine für reguläre Ausdrücke vom Zeichen am Index bis zum Zeichen am beginning Index beginning + length – 1. Wenn die Engine für reguläre Ausdrücke mithilfe der -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 RegexOptions.RightToLeft beginning + length – 1 bis 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 wiederholt die Match -Methode des zurückgegebenen Objekts Match.NextMatch 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 Match zurückgegebenen Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Objekts die Teilzeichenfolge aus , die Match dem Muster des regulären Value input Ausdrucks entspricht. Wenn keine Übereinstimmung gefunden wird, ist der Wert String.Empty .

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des übereinstimmenden Vorgangs das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors keinen Time out-Wert festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Siehe auch

Gilt für

Match(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.

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 nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

Gibt zurück

Match

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

Ausnahmen

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

input oder pattern ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

Es ist ein Timeout 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. Er verwendet die RegexOptions.IgnoreCase Option , um sicherzustellen, dass der reguläre Ausdruck Wörter sucht, die sowohl mit einem Großbuchstaben "a" als auch mit einem Kleinbuchstaben "a" beginnen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   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:

Muster Beschreibung
\b Der Vergleich beginnt an einer Wortgrenze.
a Übereinstimmung mit dem Zeichen "a".
\w* Übereinstimmung mit null, einem oder mehreren Wortzeichen.
\b Der Vergleich endet an einer Wortgrenze.

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

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und 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 -Eigenschaft des Match zurückgegebenen Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die Match -Eigenschaft des zurückgegebenen Objekts Value die Teilzeichenfolge aus input , die dem Muster des regulären Ausdrucks entspricht. Wenn keine Übereinstimmung gefunden wird, lautet der Wert String.Empty .

Diese Methode gibt die erste Teilzeichenfolge in input zurück, die dem Muster des regulären Ausdrucks entspricht. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie wiederholt die Match -Methode des zurückgegebenen Objekts NextMatch 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 abgleichenden Vorgangs das time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der die Methode aufgerufen wird. Wenn in den Eigenschaften der Anwendungsdomäne kein Time out definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Diese Methode führt nach einem Intervall, das dem Standardtime out-Wert der Anwendungsdomäne, in der sie aufgerufen wird, zu einem Time out-Wert kommt. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Timeout aufgetreten ist. Die empfohlene statische Methode zum Abrufen einer Musterabgleich ist Match(String, String) , mit der Sie das Time out-Intervall festlegen können.

Siehe auch

Gilt für

Match(String, Int32)

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks ab 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 nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

startat
Int32

Die nullbasierte Zeichenposition, an der mit der Suche begonnen werden soll.

Gibt zurück

Match

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

Ausnahmen

input ist null.

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

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die -Methode gibt die erste Teilzeichenfolge zurück, die einem Muster eines regulären Ausdrucks entspricht, beginnend bei oder nach der Zeichenposition Match(String, Int32) startat in einer Eingabezeichenfolge. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter Regular Expression Language – Kurzreferenz.

Das Muster für reguläre Ausdrücke, nach dem die Methode sucht, wird durch den Aufruf Match(String, Int32) 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 – Kurzreferenz.

Sie können optional eine Anfangsposition in der Zeichenfolge angeben, indem Sie den -Parameter startat verwenden. Wenn die Engine für reguläre Ausdrücke von links nach rechts analysiert (Standardeinstellung), werden die Übereinstimmung und der Scan nach rechts bewegt, beginnend mit dem in angegebenen startat Zeichen. Wenn die Engine für reguläre Ausdrücke von rechts nach links analysiert (wenn das Muster für reguläre Ausdrücke mit der Option erstellt wird), bewegen sich die Übereinstimmung und der Scan in die entgegengesetzte Richtung und beginnen mit dem Zeichen RegexOptions.RightToLeft startat bei -1. Wenn Sie keine Anfangsposition angeben, beginnt die Suche an der startat Standardposition. Wenn der reguläre Ausdruck von links nach rechts sucht, befindet sich die Standardposition am linken Ende von . Wenn er von rechts nach links sucht, befindet sich die Standardposition am rechten startat input Ende von startat input .

Wenn Sie eine Übereinstimmung so einschränken möchten, dass sie an einer bestimmten Zeichenposition in der Zeichenfolge beginnt und die Engine für reguläre Ausdrücke den Rest der Zeichenfolge nicht auf eine Übereinstimmung überprüft, verankern Sie den regulären Ausdruck mit einem (links für ein Muster von links nach rechts oder rechts für ein Muster von rechts nach \G links). Dies schränkt die Übereinstimmung ein, sodass sie genau bei beginnen startat muss.

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 Match zurückgegebenen Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Objekts die Teilzeichenfolge aus , die Match dem Muster des regulären Value input Ausdrucks entspricht. Wenn keine Übereinstimmung gefunden wird, ist der Wert String.Empty .

Diese Methode gibt die erste Teilzeichenfolge zurück, die an oder nach der Zeichenposition in gefunden wird, startat die dem Muster eines regulären input Ausdrucks entspricht. Sie können nachfolgende Übereinstimmungen abrufen, indem Sie wiederholt die Match -Methode des zurückgegebenen Objekts Match.NextMatch aufrufen. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, indem Sie die -Methode Regex.Matches(String, Int32) aufrufen.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des übereinstimmenden Vorgangs das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Siehe auch

Gilt für

Match(String)

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 nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

Gibt zurück

Match

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

Ausnahmen

input ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel werden Übereinstimmungen mit Mustern für reguläre Ausdrücke in einer Zeichenfolge gefunden und anschließend die übereinstimmenden Gruppen, Erfassungen und Erfassungspositionen aufgeführt.

#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 stimmt mit den Vorkommen des Worts "car" zusammen mit dem (\w+)\s+(car) vorangehenden Wort ab. Sie wird wie in der folgenden Tabelle gezeigt interpretiert.

Muster Beschreibung
(\w+) Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe.
\s+ Übereinstimmung mit mindestens einem Leerzeichen finden.
(Auto) Übereinstimmung mit der Literalzeichenfolge "car". Dies ist die zweite Erfassungsgruppe.

Hinweise

Die Match(String) -Methode gibt die erste Teilzeichenfolge zurück, die einem Muster eines regulären Ausdrucks in einer Eingabezeichenfolge entspricht. Informationen zu den Sprachelementen, die zum Erstellen eines Musters für reguläre Ausdrücke verwendet werden, finden Sie unter 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 Match zurückgegebenen Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Objekts die Teilzeichenfolge aus , die Match dem Muster des regulären Value input Ausdrucks entspricht. Wenn keine Übereinstimmung gefunden wird, ist der Wert String.Empty .

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

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des übereinstimmenden Vorgangs das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Siehe auch

Gilt für

Match(String, String)

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 nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

Gibt zurück

Match

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

Ausnahmen

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

input oder pattern ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Das folgende Beispiel ruft die -Methode auf, um das erste Wort zu suchen, das mindestens ein Zeichen enthält, und ruft dann die -Methode auf, um Match(String, String) z zusätzliche Match.NextMatch Übereinstimmungen zu finden.

using System;
using System.Text.RegularExpressions;

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:

Muster Beschreibung
\b Der Vergleich beginnt an einer Wortgrenze.
\w* Übereinstimmung mit null, einem oder mehr Wortzeichen.
z+ Übereinstimmung mit einem oder mehr Vorkommen des z Zeichens.
\w* Übereinstimmung mit null, einem oder mehr Wortzeichen.
\b Der Vergleich endet an einer Wortgrenze.

Hinweise

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

Die statische Methode entspricht dem Erstellen eines -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Match(String, String) Regex Aufrufen der Match(String) Instanzmethode. 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 Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – 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 Match zurückgegebenen Objekts Success überprüfen. Wenn eine Übereinstimmung gefunden wird, enthält die -Eigenschaft des zurückgegebenen Objekts die Teilzeichenfolge aus , die Match dem Muster des regulären Value input Ausdrucks entspricht. Wenn keine Übereinstimmung gefunden wird, ist der Wert String.Empty .

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

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Abgleichsvorgang das time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der RegexMatchTimeoutException die Methode aufgerufen wird. Wenn kein Time out in den Eigenschaften der Anwendungsdomäne definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Bei dieser Methode kommt es nach einem Intervall zu einem Time out, das dem Standardzeitwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn für die Anwendungsdomäne kein Time out-Wert definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Time out erfolgt. Die empfohlene statische Methode zum Abrufen einer Muster übereinstimmung ist Match(String, String) , mit der Sie das Time out-Intervall festlegen können.

Siehe auch

Gilt für