Match Klasa

Definicja

Przestrzeń nazw:

System.Text.RegularExpressions

Zestaw:

System.Text.RegularExpressions.dll

Zestaw:

System.dll

Zestaw:

netstandard.dll

Reprezentuje wyniki z jednego dopasowania wyrażenia regularnego.

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

Dziedziczenie

Object

Capture

Group

Match

Atrybuty

SerializableAttribute

Przykłady

W poniższych przykładach użyto wyrażenia Console\.Write(Line)?regularnego . Wyrażenie regularne jest interpretowane w następujący sposób:

Konsola\. Napisz	Dopasuj ciąg "Console.Write". Należy pamiętać, że znak "." jest ucieczki, tak aby był interpretowany jako kropka literału, a nie jako symbol wieloznaczny, który pasuje do dowolnego znaku.
(Linia)?	Dopasuj zero lub jedno wystąpienie ciągu "Line".

Przykład 1

Poniższy przykład wywołuje metodę , Regex.Matches(String, String) aby pobrać wszystkie dopasowania wzorca w ciągu wejściowym. Następnie iteruje Match obiekty w zwróconym MatchCollection obiekcie, aby wyświetlić informacje o każdym dopasowaniu.

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.

Przykład 2

Poniższy przykład wywołuje Match(String, String) metody i NextMatch w celu pobrania jednego dopasowania naraz.

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.

Uwagi

Obiekt Match jest niezmienny i nie ma publicznego konstruktora. Wystąpienie Match klasy jest zwracane przez metodę Regex.Match i reprezentuje pierwsze dopasowanie wzorca w ciągu. Kolejne dopasowania są reprezentowane przez Match obiekty zwracane przez metodę Match.NextMatch . Ponadto MatchCollection metoda zwraca Regex.Matches obiekt składający się z zera, co najmniej Match jednego obiektu.

Regex.Matches Jeśli metoda nie pasuje do wzorca wyrażenia regularnego w ciągu wejściowym, zwraca pusty MatchCollection obiekt. Następnie można użyć foreach konstrukcji w języku C# lub For Each konstrukcji w Visual Basic w celu iteracji kolekcji.

Regex.Match Jeśli metoda nie pasuje do wzorca wyrażenia regularnego, zwraca Match obiekt, który jest równy Match.Empty. Możesz użyć Success właściwości , aby określić, czy dopasowanie zakończyło się pomyślnie. Poniższy przykład stanowi ilustrację.

// 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

Jeśli dopasowanie wzorca powiedzie się, Value właściwość zawiera dopasowany podciąg, Index właściwość wskazuje pozycję początkową opartą na zera dopasowanego podciągu w ciągu wejściowym, a Length właściwość wskazuje długość dopasowanego podciągu w ciągu wejściowym.

Ponieważ pojedyncze dopasowanie może obejmować wiele grup przechwytywania, Match ma właściwość zwracającą Groups wartość GroupCollection. Samo Match wystąpienie jest równoważne pierwszemu obiektowi w kolekcji Match.Groups[0] (Match.Groups(0) w Visual Basic), który reprezentuje całe dopasowanie. Dostęp do przechwyconych grup można uzyskać w dopasowaniu w następujący sposób:

• Elementy członkowskie GroupCollection obiektu można iterować przy użyciu foreach konstrukcji (C#) lub For Each (Visual Basic).

• Możesz użyć GroupCollection.Item[Int32] właściwości , aby pobrać grupy według liczby przechwytujących grup. Należy pamiętać, że można określić, które grupy numerowane znajdują się w wyrażeniu regularnym, wywołując metodę wystąpienia Regex.GetGroupNumbers .

• Możesz użyć GroupCollection.Item[String] właściwości , aby pobrać grupy według nazwy grupy przechwytywania. Należy pamiętać, że możesz określić, które nazwane grupy znajdują się w wyrażeniu regularnym, wywołując metodę wystąpienia Regex.GetGroupNames() .

Właściwości

Captures	Pobiera kolekcję wszystkich przechwytywania dopasowanych przez grupę przechwytywania w kolejności najbardziej od lewej do lewej (lub najwsłodszej od prawej do wewnątrz, jeśli wyrażenie regularne jest modyfikowane za RightToLeft pomocą opcji). Kolekcja może zawierać zero lub więcej elementów. (Odziedziczone po Group)
Empty	Pobiera pustą grupę. Wszystkie nieudane dopasowania zwracają to puste dopasowanie.
Groups	Pobiera kolekcję grup dopasowanych przez wyrażenie regularne.
Index	Pozycja w oryginalnym ciągu, w którym znajduje się pierwszy znak przechwyconego podciągu. (Odziedziczone po Capture)
Length	Pobiera długość przechwyconego podciągu. (Odziedziczone po Capture)
Name	Zwraca nazwę grupy przechwytywania reprezentowanej przez bieżące wystąpienie. (Odziedziczone po Group)
Success	Pobiera wartość wskazującą, czy dopasowanie zakończyło się pomyślnie. (Odziedziczone po Group)
Value	Pobiera przechwycony podciąg z ciągu wejściowego. (Odziedziczone po Capture)
ValueSpan	Pobiera przechwycony zakres z ciągu wejściowego. (Odziedziczone po Capture)

Metody

Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
NextMatch()	Zwraca nowy Match obiekt z wynikami następnego dopasowania, zaczynając od pozycji, w której zakończyło się ostatnie dopasowanie (w znaku po ostatnim dopasowanym znaku).
Result(String)	Zwraca rozszerzenie określonego wzorca zastępczego.
Synchronized(Match)	Match Zwraca wystąpienie równoważne podanemu wystąpieniu, które jest odpowiednie do współużytkowania między wieloma wątkami.
ToString()	Pobiera przechwycony podciąg z ciągu wejściowego, wywołując Value właściwość . (Odziedziczone po Capture)

Zobacz też

• MatchCollection
• Regex