Match Classe

Definizione

Spazio dei nomi:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Assembly:

System.dll

Assembly:

netstandard.dll

Rappresenta i risultati di una singola corrispondenza di un'espressione regolare.

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

Ereditarietà

Object

Capture

Group

Match

Attributi

SerializableAttribute

Esempio

Gli esempi seguenti usano l'espressione Console\.Write(Line)?regolare . L'espressione regolare viene interpretata nel modo seguente.

Console\. Scrivere	Trova la corrispondenza con la stringa "Console.Write". Si noti che il carattere "." viene eseguito in escape in modo che venga interpretato come punto letterale anziché come carattere jolly che corrisponda a qualsiasi carattere.
(Riga)?	Trova la corrispondenza con zero o una occorrenza della stringa "Line".

Esempio 1

Nell'esempio seguente viene chiamato il Regex.Matches(String, String) metodo per recuperare tutte le corrispondenze del modello in una stringa di input. Esegue quindi l'iterazione degli Match oggetti nell'oggetto restituito MatchCollection per visualizzare informazioni su ogni corrispondenza.

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.

Esempio 2

Nell'esempio seguente vengono chiamati i Match(String, String) metodi e NextMatch per recuperare una corrispondenza alla volta.

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.

Commenti

L'oggetto Match non è modificabile e non ha alcun costruttore pubblico. Un'istanza Match della classe viene restituita dal Regex.Match metodo e rappresenta la prima corrispondenza del modello in una stringa. Le corrispondenze successive sono rappresentate dagli Match oggetti restituiti dal Match.NextMatch metodo . Inoltre, un MatchCollection oggetto costituito da zero, uno o più Match oggetti viene restituito dal Regex.Matches metodo .

Se il Regex.Matches metodo non corrisponde a un modello di espressione regolare in una stringa di input, restituisce un oggetto vuoto MatchCollection . È quindi possibile usare un costrutto in C# o un foreach For Each costrutto in Visual Basic per scorrere la raccolta.

Se il Regex.Match metodo non corrisponde al modello di espressione regolare, restituisce un Match oggetto uguale a Match.Empty. È possibile usare la Success proprietà per determinare se la corrispondenza è riuscita. Nell'esempio seguente viene illustrato questo concetto.

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

Se una corrispondenza del modello ha esito positivo, la Value proprietà contiene la sottostringa corrispondente, la Index proprietà indica la posizione iniziale in base zero della sottostringa corrispondente nella stringa di input e la Length proprietà indica la lunghezza della sottostringa corrispondente nella stringa di input.

Poiché una singola corrispondenza può coinvolgere più gruppi di acquisizione, Match ha una Groups proprietà che restituisce l'oggetto GroupCollection. L'istanza Match stessa equivale al primo oggetto della raccolta, in Match.Groups[0] (Match.Groups(0) in Visual Basic), che rappresenta l'intera corrispondenza. È possibile accedere ai gruppi acquisiti in una corrispondenza nei modi seguenti:

• È possibile eseguire l'iterazione dei membri dell'oggetto GroupCollection usando un foreach costrutto (C#) o For Each (Visual Basic).

• È possibile usare la GroupCollection.Item[Int32] proprietà per recuperare i gruppi in base al numero del gruppo di acquisizione. Si noti che è possibile determinare quali gruppi numerati sono presenti in un'espressione regolare chiamando il metodo di istanza Regex.GetGroupNumbers .

• È possibile usare la GroupCollection.Item[String] proprietà per recuperare i gruppi in base al nome del gruppo di acquisizione. Si noti che è possibile determinare quali gruppi denominati sono presenti in un'espressione regolare chiamando il metodo di istanza Regex.GetGroupNames() .

Proprietà

Captures	Ottiene una raccolta di tutte le acquisizioni rilevate dal gruppo di acquisizione, nel primo ordine più interno e più a sinistra (o nel primo ordine più interno e più a destra se l'espressione regolare viene modificata con l'opzione RightToLeft). La raccolta può avere zero o più elementi. (Ereditato da Group)
Empty	Ottiene il gruppo vuoto. Tutte le corrispondenze non riuscite restituiscono questa corrispondenza vuota.
Groups	Ottiene una raccolta di gruppi corrispondenti all'espressione regolare.
Index	Posizione nella stringa originale in cui si trova il primo carattere della sottostringa acquisita. (Ereditato da Capture)
Length	Ottiene la lunghezza della sottostringa acquisita. (Ereditato da Capture)
Name	Restituisce nome del gruppo di acquisizione rappresentato dall'istanza corrente. (Ereditato da Group)
Success	Ottiene un valore che indica se la ricerca di corrispondenze ha avuto esito positivo. (Ereditato da Group)
Value	Ottiene la sottostringa acquisita dalla stringa di input. (Ereditato da Capture)
ValueSpan	Ottiene l'intervallo acquisito dalla stringa di input. (Ereditato da Capture)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
NextMatch()	Restituisce un nuovo oggetto Match con i risultati relativi alla corrispondenza successiva, partendo dalla posizione in cui terminava l'ultima corrispondenza (dal carattere dopo l'ultimo carattere corrispondente).
Result(String)	Restituisce l'espansione del criterio di sostituzione specificato.
Synchronized(Match)	Restituisce un'istanza di Match equivalente a quella fornita che può essere condivisa tra più thread.
ToString()	Recupera la sottostringa acquisita dalla stringa di input chiamando la proprietà Value. (Ereditato da Capture)

Vedi anche

• MatchCollection
• Regex