Match Klasse

Definition

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

Object

Capture

Group

Match

Attribute

SerializableAttribute

Beispiele

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

Beispiel 1

Im folgenden Beispiel wird die Regex.Matches(String, String) Methode aufgerufen, um alle Mustervergleiche in einer Eingabezeichenfolge abzurufen. Anschließend werden die Match Objekte im zurückgegebenen MatchCollection Objekt durchsucht, um Informationen zu den einzelnen Übereinstimmungen 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 und NextMatch die Match(String, String) Methoden 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 weist keinen öffentlichen Konstruktor auf. Eine Instanz der Match Klasse wird von der Regex.Match Methode zurückgegeben und stellt die erste Mustervergleichung in einer Zeichenfolge dar. Nachfolgende Übereinstimmungen werden durch Match objekte dargestellt, die von der Match.NextMatch Methode zurückgegeben werden. Darüber hinaus wird ein MatchCollection Objekt, das aus Null, einem oder mehreren Match Objekten besteht, 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, wird ein leeres MatchCollection Objekt zurückgegeben. Sie können dann ein foreach Konstrukt in C# oder ein For Each Konstrukt in Visual Basic verwenden, um die Auflistung zu durchlaufen.

Wenn die Regex.Match Methode nicht mit dem Muster für reguläre Ausdrücke übereinstimmt, wird ein Match Objekt zurückgegeben, das gleich ist Match.Empty. Mit der Success Eigenschaft können Sie ermitteln, 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überstimmung 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 Aufnahmegruppen umfassen kann, verfügt sie über eine Groups Eigenschaft, Match die den GroupCollectionWert zurückgibt. Die Match Instanz selbst entspricht dem ersten Objekt in der Auflistung unter Match.Groups[0] (Match.Groups(0) in Visual Basic), das die gesamte Übereinstimmung darstellt. Sie können auf die erfassten Gruppen auf folgende Weise auf eine Übereinstimmung zugreifen:

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

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

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

Weitere Informationen

• MatchCollection
• Regex