Match Classe

Définition

Espace de noms:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Assembly:

System.dll

Assembly:

netstandard.dll

Représente les résultats d'une correspondance d'expression régulière unique.

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

Héritage

Object

Capture

Group

Match

Attributs

SerializableAttribute

Exemples

Les exemples suivants utilisent l’expression Console\.Write(Line)?régulière . L'expression régulière est interprétée comme suit :

Console\. Écrire	Mettre en correspondance la chaîne « Console.Write ». Notez que le caractère « . » est placé dans une séquence d’échappement afin qu’il soit interprété comme un point littéral plutôt que comme un caractère générique qui correspond à n’importe quel caractère.
(Ligne) ?	Mettre en correspondance zéro ou une occurrence de la chaîne « Line ».

Exemple 1

L’exemple suivant appelle la Regex.Matches(String, String) méthode pour récupérer toutes les correspondances de modèle dans une chaîne d’entrée. Il itère ensuite les Match objets dans l’objet retourné MatchCollection pour afficher des informations sur chaque correspondance.

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.

Exemple 2

L’exemple suivant appelle les méthodes et NextMatch les Match(String, String) méthodes pour récupérer une correspondance à la fois.

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.

Remarques

L’objet Match est immuable et n’a aucun constructeur public. Une instance de la Match classe est retournée par la Regex.Match méthode et représente la première correspondance de modèle dans une chaîne. Les correspondances suivantes sont représentées par Match les objets retournés par la Match.NextMatch méthode. En outre, un MatchCollection objet qui se compose de zéro, un ou plusieurs Match objets est retourné par la Regex.Matches méthode.

Si la Regex.Matches méthode ne correspond pas à un modèle d’expression régulière dans une chaîne d’entrée, elle retourne un objet vide MatchCollection . Vous pouvez ensuite utiliser une foreach construction en C# ou une For Each construction dans Visual Basic pour itérer la collection.

Si la Regex.Match méthode ne correspond pas au modèle d’expression régulière, elle retourne un Match objet égal à Match.Empty. Vous pouvez utiliser la Success propriété pour déterminer si la correspondance a réussi. L'exemple suivant illustre cette situation.

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

Si une correspondance de modèle réussit, la Value propriété contient la sous-chaîne correspondante, la Index propriété indique la position de départ de base zéro de la sous-chaîne correspondante dans la chaîne d’entrée, et la Length propriété indique la longueur de la sous-chaîne correspondante dans la chaîne d’entrée.

Étant donné qu’une correspondance unique peut impliquer plusieurs groupes de capture, Match a une Groups propriété qui retourne le GroupCollection. L’instance Match elle-même est équivalente au premier objet de la collection, à Match.Groups[0] (Match.Groups(0) dans Visual Basic), qui représente la correspondance entière. Vous pouvez accéder aux groupes capturés dans une correspondance de la manière suivante :

• Vous pouvez itérer les membres de l’objet GroupCollection à l’aide d’une foreach construction (C#) ou For Each (Visual Basic).

• Vous pouvez utiliser la GroupCollection.Item[Int32] propriété pour récupérer des groupes par le nombre du groupe de capture. Notez que vous pouvez déterminer quels groupes numérotés sont présents dans une expression régulière en appelant la méthode d’instance Regex.GetGroupNumbers .

• Vous pouvez utiliser la GroupCollection.Item[String] propriété pour récupérer des groupes par le nom du groupe de capture. Notez que vous pouvez déterminer quels groupes nommés sont présents dans une expression régulière en appelant la méthode d’instance Regex.GetGroupNames() .

Propriétés

Captures	Obtient une collection de toutes les captures correspondant au groupe de capture, dans l'ordre du plus profond et du plus à gauche (ou dans l'ordre du plus profond et du plus à droite, si l'expression régulière est modifiée par l'option RightToLeft). La collection peut contenir entre zéro et plusieurs éléments. (Hérité de Group)
Empty	Obtient le groupe vide. Toutes les correspondances infructueuses retournent cette correspondance vide.
Groups	Obtient une collection de groupes correspondant à l'expression régulière.
Index	Position dans la chaîne d'origine où se trouve le premier caractère de la sous-chaîne capturée. (Hérité de Capture)
Length	Obtient la longueur de la sous-chaîne capturée. (Hérité de Capture)
Name	Retourne le nom du groupe de capture représenté par l’instance actuelle. (Hérité de Group)
Success	Obtient une valeur indiquant si la correspondance est réussie. (Hérité de Group)
Value	Obtient la sous-chaîne capturée à partir de la chaîne d'entrée. (Hérité de Capture)
ValueSpan	Obtient l’étendue capturée à partir de la chaîne d’entrée. (Hérité de Capture)

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
NextMatch()	Retourne un nouvel objet Match avec les résultats de la correspondance suivante, en commençant à la position à laquelle la dernière correspondance s'est terminée (au niveau du caractère qui se trouve après le dernier caractère correspondant).
Result(String)	Retourne l’extension du modèle de remplacement spécifié.
Synchronized(Match)	Retourne une instance de Match équivalente à celle qui est fournie, dont le partage entre plusieurs threads est possible.
ToString()	Récupère la sous-chaîne capturée de la chaîne d'entrée en appelant la propriété Value. (Hérité de Capture)

Voir aussi

• MatchCollection
• Regex