Match Classe

Definizione

Rappresenta i risultati di una singola corrispondenza di un'espressione regolare.Represents the results from a single regular expression match.

public ref class Match : System::Text::RegularExpressions::Group
[System.Serializable]
public class Match : System.Text.RegularExpressions.Group
type Match = class
    inherit Group
Public Class Match
Inherits Group
Ereditarietà
Attributi

Esempi

Negli esempi seguenti viene usata l'espressione Console\.Write(Line)?regolare.The following examples use the regular expression Console\.Write(Line)?. L'espressione regolare viene interpretata nel modo seguente.The regular expression is interpreted as follows:

Console\.WriteConsole\.Write Trova la corrispondenza con la stringa "Console.Write".Match the string "Console.Write". Si noti che il carattere "." viene preceduto da un carattere di escape, in modo che venga interpretato come un periodo letterale anziché come un carattere jolly che corrisponda a qualsiasi carattere.Note that the "." character is escaped so that it is interpreted as a literal period rather than as a wildcard that matches any character.
(Linea)?(Line)? Trova la corrispondenza con zero o una occorrenza della stringa "Line".Match zero or one occurrence of the string "Line".

Esempio 1Example 1

Nell'esempio seguente viene chiamato Regex.Matches(String, String) il metodo per recuperare tutte le corrispondenze dei modelli in una stringa di input.The following example calls the Regex.Matches(String, String) method to retrieve all pattern matches in an input string. Esegue quindi l' Match iterazione degli oggetti nell'oggetto MatchCollection restituito per visualizzare informazioni su ogni corrispondenza.It then iterates the Match objects in the returned MatchCollection object to display information about each match.

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 115.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 211.
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 2Example 2

Nell'esempio seguente vengono chiamati Match(String, String) i NextMatch metodi e per recuperare una corrispondenza alla volta.The following example calls the Match(String, String) and NextMatch methods to retrieve one match at a time.

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 115.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 211.
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' Match oggetto non è modificabile e non dispone di un costruttore pubblico.The Match object is immutable and has no public constructor. Un'istanza della Match classe viene restituita Regex.Match dal metodo e rappresenta la prima corrispondenza del criterio in una stringa.An instance of the Match class is returned by the Regex.Match method and represents the first pattern match in a string. Match LeMatch.NextMatch corrispondenze successive sono rappresentate da oggetti restituiti dal metodo.Subsequent matches are represented by Match objects returned by the Match.NextMatch method. Inoltre, il MatchCollection Match metodorestituisceunoggettocostituitodazero,unoRegex.Matches o più oggetti.In addition, a MatchCollection object that consists of zero, one, or more Match objects is returned by the Regex.Matches method.

Se il Regex.Matches metodo non riesce a trovare una corrispondenza con un criterio di espressione regolare in una stringa di MatchCollection input, restituisce un oggetto vuoto.If the Regex.Matches method fails to match a regular expression pattern in an input string, it returns an empty MatchCollection object. È quindi possibile usare un foreach costrutto C# in o For Each un costrutto in Visual Basic per eseguire l'iterazione della raccolta.You can then use a foreach construct in C# or a For Each construct in Visual Basic to iterate the collection.

Se il Regex.Match metodo non riesce a trovare la corrispondenza con il criterio di espressione Match regolare, restituisce un oggetto Match.Emptyuguale a.If the Regex.Match method fails to match the regular expression pattern, it returns a Match object that is equal to Match.Empty. È possibile usare la Success proprietà per determinare se la corrispondenza ha avuto esito positivo.You can use the Success property to determine whether the match was successful. Nell'esempio seguente viene illustrato questo concetto.The following example provides an illustration.

// 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 di criteri ha esito Value positivo, la proprietà contiene la sottostringa Index corrispondente, la proprietà indica la posizione iniziale in base zero della sottostringa corrispondente nella stringa di input e Length la proprietà indica lunghezza della sottostringa corrispondente nella stringa di input.If a pattern match is successful, the Value property contains the matched substring, the Index property indicates the zero-based starting position of the matched substring in the input string, and the Length property indicates the length of matched substring in the input string.

Poiché una singola corrispondenza può coinvolgere più gruppi di acquisizione Match , dispone Groups di una proprietà che GroupCollectionrestituisce.Because a single match can involve multiple capturing groups, Match has a Groups property that returns the GroupCollection. L' Match istanza stessa è equivalente al primo oggetto nella raccolta, in corrispondenza Match.Groups[0] di (Match.Groups(0) in Visual Basic), che rappresenta l'intera corrispondenza.The Match instance itself is equivalent to the first object in the collection, at Match.Groups[0] (Match.Groups(0) in Visual Basic), which represents the entire match. È possibile accedere ai gruppi acquisiti in una corrispondenza nei modi seguenti:You can access the captured groups in a match in the following ways:

  • È possibile GroupCollection scorrere i membri dell'oggetto usando un foreach costrutto (C#) o For Each (Visual Basic).You can iterate the members of the GroupCollection object by using a foreach (C#) or For Each (Visual Basic) construct.

  • È possibile usare la GroupCollection.Item[Int32] proprietà per recuperare i gruppi in base al numero del gruppo di acquisizione.You can use the GroupCollection.Item[Int32] property to retrieve groups by the number of the capturing group. Si noti che è possibile determinare i gruppi numerati presenti in un'espressione regolare chiamando il metodo di Regex.GetGroupNumbers istanza.Note that you can determine which numbered groups are present in a regular expression by calling the instance Regex.GetGroupNumbers method.

  • È possibile usare la GroupCollection.Item[String] proprietà per recuperare i gruppi in base al nome del gruppo di acquisizione.You can use the GroupCollection.Item[String] property to retrieve groups by the name of the capturing group. Si noti che è possibile determinare quali gruppi denominati sono presenti in un'espressione regolare chiamando Regex.GetGroupNames() il metodo di istanza.Note that you can determine which named groups are present in a regular expression by calling the instance Regex.GetGroupNames() method.

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).Gets a collection of all the captures matched by the capturing group, in innermost-leftmost-first order (or innermost-rightmost-first order if the regular expression is modified with the RightToLeft option). La raccolta può avere zero o più elementi.The collection may have zero or more items.

(Ereditato da Group)
Empty

Ottiene il gruppo vuoto.Gets the empty group. Tutte le ricerche di corrispondenze non riuscite restituiscono questa corrispondenza vuota.All failed matches return this empty match.

Groups

Ottiene una raccolta di gruppi che corrispondono all'espressione regolare.Gets a collection of groups matched by the regular expression.

Index

Posizione nella stringa originale in cui si trova il primo carattere della sottostringa acquisita.The position in the original string where the first character of the captured substring is found.

(Ereditato da Capture)
Length

Ottiene la lunghezza della sottostringa acquisita.Gets the length of the captured substring.

(Ereditato da Capture)
Name

Restituisce nome del gruppo di acquisizione rappresentato dall'istanza corrente.Returns the name of the capturing group represented by the current instance.

(Ereditato da Group)
Success

Ottiene un valore che indica se la ricerca di corrispondenze ha avuto esito positivo.Gets a value indicating whether the match is successful.

(Ereditato da Group)
Value

Ottiene la sottostringa acquisita dalla stringa di input.Gets the captured substring from the input string.

(Ereditato da Capture)

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(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 rilevato dalla corrispondenza).Returns a new Match object with the results for the next match, starting at the position at which the last match ended (at the character after the last matched character).

Result(String)

Restituisce l'espansione del criterio di sostituzione specificato.Returns the expansion of the specified replacement pattern.

Synchronized(Match)

Restituisce un'istanza di Match equivalente a quella fornita che può essere condivisa tra più thread.Returns a Match instance equivalent to the one supplied that is suitable to share between multiple threads.

ToString()

Recupera la sottostringa acquisita dalla stringa di input chiamando la proprietà Value.Retrieves the captured substring from the input string by calling the Value property.

(Ereditato da Capture)

Si applica a

Vedi anche