Match Klass

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

Arv

Object

Capture

Group

Match

Attribut

SerializableAttribute

Exempel

I följande exempel används det reguljära uttrycket Console\.Write(Line)?. Det reguljära uttrycket tolkas på följande sätt:

Exempel 1

I följande exempel anropas Regex.Matches(String, String) metoden för att hämta alla mönstermatchningar i en indatasträng. Sedan itererar den objekten Match i det returnerade MatchCollection objektet för att visa information om varje matchning.

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.

Exempel 2

I följande exempel anropas Match(String, String) metoderna och NextMatch för att hämta en matchning i taget.

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.

Kommentarer

Objektet Match är oföränderligt och har ingen offentlig konstruktor. En instans av Match klassen returneras av Regex.Match metoden och representerar den första mönstermatchningen i en sträng. Efterföljande matchningar representeras av Match objekt som returneras av Match.NextMatch metoden. Dessutom returneras ett MatchCollection objekt som består av noll, ett eller flera Match objekt av Regex.Matches metoden.

Regex.Matches Om metoden inte matchar ett mönster för reguljära uttryck i en indatasträng returneras ett tomt MatchCollection objekt. Du kan sedan använda en foreach-konstruktion i C# eller en For Each-konstruktion i Visual Basic för att iterera samlingen.

Regex.Match Om metoden inte matchar mönstret för reguljära uttryck returneras ett Match objekt som är lika Match.Emptymed . Du kan använda egenskapen Success för att avgöra om matchningen lyckades. I följande exempel visas en bild.

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

Om en mönstermatchning lyckas Value innehåller egenskapen den matchade delsträngen Index , egenskapen anger den nollbaserade startpositionen för den matchade delsträngen i indatasträngen Length och egenskapen anger längden på matchad delsträng i indatasträngen.

Eftersom en enskild matchning kan omfatta flera insamlingsgrupper har Match en Groups egenskap som returnerar GroupCollection. Själva Match-instansen motsvarar det första objektet i samlingen, på Match.Groups[0] (Match.Groups(0) i Visual Basic), som representerar hela matchningen. Du kan komma åt de insamlade grupperna i en matchning på följande sätt:

• Du kan iterera medlemmarna i objektet GroupCollection med hjälp av en foreach (C#) eller For Each (Visual Basic).

• Du kan använda egenskapen GroupCollection.Item[Int32] för att hämta grupper efter antalet avbildningsgrupper. Observera att du kan avgöra vilka numrerade grupper som finns i ett reguljärt uttryck genom att anropa instansmetoden Regex.GetGroupNumbers .

• Du kan använda GroupCollection.Item[String] egenskapen för att hämta grupper med namnet på insamlingsgruppen. Observera att du kan avgöra vilka namngivna grupper som finns i ett reguljärt uttryck genom att anropa instansmetoden Regex.GetGroupNames() .

Se även

• MatchCollection
• Regex