Match Klasse

Definition

Stellt die Ergebnisse aus einer einzelnen Übereinstimmung mit einem regulären Ausdruck dar.

public ref class Match : System::Text::RegularExpressions::Group
public class Match : System.Text.RegularExpressions.Group
[System.Serializable]
public class Match : System.Text.RegularExpressions.Group
type Match = class
    inherit Group
[<System.Serializable>]
type Match = class
    inherit Group
Public Class Match
Inherits Group
Vererbung
Attribute

Beispiele

In den folgenden Beispielen wird der reguläre Ausdruck Console\.Write(Line)? verwendet. Der reguläre Ausdruck wird wie folgt interpretiert:

Konsole \ . Schreiben Übereinstimmung mit der Zeichenfolge „Console.Write“. Beachten Sie, dass das Zeichen "." als Escapezeichen verwendet wird, sodass es als Literalzeitraum und nicht als Platzhalter interpretiert wird, der einem beliebigen Zeichen entspricht.
(Zeile)? Übereinstimmung mit null oder einem Vorkommen der Zeichenfolge „Line“.

Beispiel 1

Im folgenden Beispiel wird die Regex.Matches(String, String) -Methode aufgerufen, um alle Muster übereinstimmungen in einer Eingabezeichenfolge abzurufen. Anschließend werden die Match Objekte im zurückgegebenen Objekt durchläuft, um MatchCollection Informationen zu jeder Übereinstimmung anzuzeigen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "int[] values = { 1, 2, 3 };\n" +
                     "for (int ctr = values.GetLowerBound(1); ctr <= values.GetUpperBound(1); ctr++)\n" +
                     "{\n" +
                     "   Console.Write(values[ctr]);\n" +
                     "   if (ctr < values.GetUpperBound(1))\n" +
                     "      Console.Write(\", \");\n" +
                     "}\n" +
                     "Console.WriteLine();\n";   
      
      string pattern = @"Console\.Write(Line)?";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine("'{0}' found in the source code at position {1}.",  
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//    'Console.Write' found in the source code at position 112.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 207.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Dim values() As Integer = { 1, 2, 3 }" & vbCrLf & _
                            "For ctr As Integer = values.GetLowerBound(1) To values.GetUpperBound(1)" & vbCrLf & _
                            "   Console.Write(values(ctr))" & vbCrLf & _
                            "   If ctr < values.GetUpperBound(1) Then Console.Write("", "")" & vbCrLf & _
                            "Next" & vbCrLf & _
                            "Console.WriteLine()"   
      Dim pattern As String = "Console\.Write(Line)?"
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine("'{0}' found in the source code at position {1}.", _ 
                           match.Value, match.Index)       
      Next                            
   End Sub
End Module
' The example displays the following output:
'    'Console.Write' found in the source code at position 115.
'    'Console.Write' found in the source code at position 184.
'    'Console.WriteLine' found in the source code at position 211.

Beispiel 2

Im folgenden Beispiel werden die Match(String, String) Methoden und NextMatch aufgerufen, um jeweils eine Übereinstimmung abzurufen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "int[] values = { 1, 2, 3 };\n" +
                     "for (int ctr = values.GetLowerBound(1); ctr <= values.GetUpperBound(1); ctr++)\n" +
                     "{\n" +
                     "   Console.Write(values[ctr]);\n" +
                     "   if (ctr < values.GetUpperBound(1))\n" +
                     "      Console.Write(\", \");\n" +
                     "}\n" +
                     "Console.WriteLine();\n";   
      string pattern = @"Console\.Write(Line)?";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("'{0}' found in the source code at position {1}.",  
                           match.Value, match.Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//    'Console.Write' found in the source code at position 112.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 207.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Dim values() As Integer = { 1, 2, 3 }" & vbCrLf & _
                            "For ctr As Integer = values.GetLowerBound(1) To values.GetUpperBound(1)" & vbCrLf & _
                            "   Console.Write(values(ctr))" & vbCrLf & _
                            "   If ctr < values.GetUpperBound(1) Then Console.Write("", "")" & vbCrLf & _
                            "Next" & vbCrLf & _
                            "Console.WriteLine()"   
      Dim pattern As String = "Console\.Write(Line)?"
      Dim match As Match = Regex.Match(input, pattern)
      Do While match.Success
         Console.WriteLine("'{0}' found in the source code at position {1}.", _ 
                           match.Value, match.Index)
         match = match.NextMatch()                  
      Loop                            
   End Sub
End Module
' The example displays the following output:
'    'Console.Write' found in the source code at position 115.
'    'Console.Write' found in the source code at position 184.
'    'Console.WriteLine' found in the source code at position 211.

Hinweise

Das Match Objekt ist unveränderlich und verfügt über keinen öffentlichen Konstruktor. Eine Instanz der Match -Klasse wird von der -Methode zurückgegeben Regex.Match und stellt die erste Muster übereinstimmung in einer Zeichenfolge dar. Nachfolgende Übereinstimmungen werden durch -Objekte dargestellt, Match die von der -Methode zurückgegeben Match.NextMatch werden. Darüber hinaus wird ein MatchCollection -Objekt, das aus null, einem oder mehreren -Objekten besteht, Match von der Regex.Matches -Methode zurückgegeben.

Wenn die Regex.Matches -Methode nicht mit einem Muster für reguläre Ausdrücke in einer Eingabezeichenfolge übereinstimmt, gibt sie ein leeres MatchCollection -Objekt zurück. Sie können dann ein foreach -Konstrukt in C# oder ein For Each -Konstrukt in Visual Basic verwenden, um die Auflistung zu iterieren.

Wenn die Regex.Match Methode nicht mit dem Muster für reguläre Ausdrücke übereinstimmt, gibt sie ein Match -Objekt zurück, das gleich Match.Empty ist. Sie können die Success -Eigenschaft verwenden, um zu bestimmen, ob die Übereinstimmung erfolgreich war. Dies wird im folgenden Beispiel veranschaulicht.

// Search for a pattern that is not found in the input string.
string pattern = "dog";
string input = "The cat saw the other cats playing in the back yard.";
Match match = Regex.Match(input, pattern);
if (match.Success )
   // Report position as a one-based integer.
   Console.WriteLine("'{0}' was found at position {1} in '{2}'.", 
                     match.Value, match.Index + 1, input);
else
   Console.WriteLine("The pattern '{0}' was not found in '{1}'.",
                     pattern, input);
' Search for a pattern that is not found in the input string.
Dim pattern As String = "dog"
Dim input As String = "The cat saw the other cats playing in the back yard."
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
   ' Report position as a one-based integer.
   Console.WriteLine("'{0}' was found at position {1} in '{2}'.", _ 
                     match.Value, match.Index + 1, input)
Else
   Console.WriteLine("The pattern '{0}' was not found in '{1}'.", _
                     pattern, input)
End If

Wenn eine Muster übereinstimmung erfolgreich ist, enthält die Value -Eigenschaft die übereinstimmende Teilzeichenfolge, die Index -Eigenschaft gibt die nullbasierte Anfangsposition der übereinstimmenden Teilzeichenfolge in der Eingabezeichenfolge an, und die Length -Eigenschaft gibt die Länge der übereinstimmenden Teilzeichenfolge in der Eingabezeichenfolge an.

Da eine einzelne Übereinstimmung mehrere Erfassungsgruppen umfassen kann, verfügt über Match eine Groups -Eigenschaft, die GroupCollection zurückgibt. Die Match Instanz selbst entspricht dem ersten Objekt in der Auflistung unter Match.Groups[0] ( in Match.Groups(0) Visual Basic), das die gesamte Übereinstimmung darstellt. Sie können auf folgende Weise auf die erfassten Gruppen in einer Übereinstimmung zugreifen:

  • Sie können die Member des GroupCollection Objekts mithilfe eines foreach (C#)- oder For Each (Visual Basic)-Konstrukts iterieren.

  • Sie können die GroupCollection.Item[Int32] -Eigenschaft verwenden, um Gruppen nach der Nummer der Erfassungsgruppe abzurufen. Beachten Sie, dass Sie bestimmen können, welche nummerierten Gruppen in einem regulären Ausdruck vorhanden sind, indem Sie die Regex.GetGroupNumbers Instanzmethode aufrufen.

  • Sie können die GroupCollection.Item[String] -Eigenschaft verwenden, um Gruppen nach dem Namen der Erfassungsgruppe abzurufen. Beachten Sie, dass Sie bestimmen können, welche benannten Gruppen in einem regulären Ausdruck vorhanden sind, indem Sie die Regex.GetGroupNames() Instanzmethode aufrufen.

Eigenschaften

Captures

Ruft eine Auflistung aller der Erfassungsgruppe entsprechenden Erfassungsübereinstimmungen in der Reihenfolge von innen nach außen und von links nach rechts ab (oder in der Reihenfolge von innen nach außen und von rechts nach links bei einer Änderung des regulären Ausdrucks mit der RightToLeft-Option). Die Auflistung kann 0 (null) oder mehr Elemente enthalten.

(Geerbt von Group)
Empty

Ruft die leere Gruppe ab. Alle fehlgeschlagenen Übereinstimmungen geben diese leere Übereinstimmung zurück.

Groups

Ruft eine Auflistung der mit dem regulären Ausdruck übereinstimmenden Gruppen ab.

Index

Die Position in der ursprünglichen Zeichenfolge, an der das erste Zeichen der aufgezeichneten Teilzeichenfolge gefunden wurde.

(Geerbt von Capture)
Length

Ruft die Länge der aufgezeichneten Teilzeichenfolge ab.

(Geerbt von Capture)
Name

Gibt der Name der Erfassungsgruppe, die die aktuelle Instanz darstellt.

(Geerbt von Group)
Success

Ruft einen Wert ab, der angibt, ob die Übereinstimmung erfolgreich ist.

(Geerbt von Group)
Value

Ruft die aufgezeichnete Teilzeichenfolge aus der Eingabezeichenfolge ab.

(Geerbt von Capture)
ValueSpan

Ruft die erfasste Spanne aus der Eingabezeichenfolge ab.

(Geerbt von Capture)

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
NextMatch()

Gibt ein neues Match-Objekt mit den Ergebnissen für die nächste Übereinstimmung zurück und beginnt dabei an der Endposition der vorherigen Übereinstimmung (mit dem Zeichen, das dem letzten übereinstimmenden Zeichen folgt).

Result(String)

Gibt die Erweiterung des angegebenen Ersetzungsmusters zurück.

Synchronized(Match)

Gibt eine der bereitgestellten Instanz entsprechende Match-Instanz zurück, die von mehreren Threads gemeinsam verwendet werden kann.

ToString()

Ruft die erfasste Teilzeichenfolge von der Eingabezeichenfolge durch Aufrufen der Value-Eigenschaft ab.

(Geerbt von Capture)

Gilt für

Siehe auch