Capture Classe

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente le résultat d'une capture de sous-expression unique ayant réussi.

public ref class Capture

public class Capture

[System.Serializable]
public class Capture

type Capture = class

[<System.Serializable>]
type Capture = class

Public Class Capture

Héritage: Object
Capture

Dérivé: System.Text.RegularExpressions.Group

Attributs: SerializableAttribute

Exemples

L’exemple suivant définit une expression régulière qui correspond aux phrases qui ne contiennent pas de ponctuation, sauf pour un point (« . »).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Yes. This dog is very friendly.";
      string pattern = @"((\w+)[\s.])+";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("Match: {0}", match.Value);
         for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
         {
            Group group = match.Groups[groupCtr];
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            for (int captureCtr = 0; captureCtr < group.Captures.Count; captureCtr++)
               Console.WriteLine("      Capture {0}: {1}", captureCtr, 
                                 group.Captures[captureCtr].Value);
         }                      
      }
   }
}
// The example displays the following output:
//       Match: Yes.
//          Group 0: Yes.
//             Capture 0: Yes.
//          Group 1: Yes.
//             Capture 0: Yes.
//          Group 2: Yes
//             Capture 0: Yes
//       Match: This dog is very friendly.
//          Group 0: This dog is very friendly.
//             Capture 0: This dog is very friendly.
//          Group 1: friendly.
//             Capture 0: This
//             Capture 1: dog
//             Capture 2: is
//             Capture 3: very
//             Capture 4: friendly.
//          Group 2: friendly
//             Capture 0: This
//             Capture 1: dog
//             Capture 2: is
//             Capture 3: very
//             Capture 4: friendly

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Yes. This dog is very friendly."
      Dim pattern As String = "((\w+)[\s.])+"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Match: {0}", match.Value)
         For groupCtr As Integer = 0 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            For captureCtr As Integer = 0 To group.Captures.Count - 1
               Console.WriteLine("      Capture {0}: {1}", captureCtr, _
                                 group.Captures(captureCtr).Value)
            Next
         Next                      
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: Yes.
'          Group 0: Yes.
'             Capture 0: Yes.
'          Group 1: Yes.
'             Capture 0: Yes.
'          Group 2: Yes
'             Capture 0: Yes
'       Match: This dog is very friendly.
'          Group 0: This dog is very friendly.
'             Capture 0: This dog is very friendly.
'          Group 1: friendly.
'             Capture 0: This
'             Capture 1: dog
'             Capture 2: is
'             Capture 3: very
'             Capture 4: friendly.
'          Group 2: friendly
'             Capture 0: This
'             Capture 1: dog
'             Capture 2: is
'             Capture 3: very
'             Capture 4: friendly

Le modèle d'expression régulière ((\w+)[\s.])+ est défini comme indiqué dans le tableau suivant. Notez que dans cette expression régulière, un quantificateur (+) est appliqué à l’expression régulière entière.

Modèle	Description
`(\w+)`	Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du deuxième groupe de capture.
`[\s.])`	Mettre en correspondance un caractère d’espace blanc ou un point (« . »).
`((\w+)[\s.])`	Mettre en correspondance un ou plusieurs caractères de mot suivis d’un espace blanc ou d’un point (« . »). Il s'agit du premier groupe de capture.
`((\w+)[\s.])+`	Mettre en correspondance une ou plusieurs occurrences d’un caractère ou d’un caractère de mot suivi d’un espace blanc ou d’un point (« . »).

Dans cet exemple, la chaîne d’entrée se compose de deux phrases. Comme le montre la sortie, la première phrase se compose d’un seul mot, de sorte que l’objet CaptureCollection a un seul Capture objet qui représente la même capture que l’objet Group . La deuxième phrase se compose de plusieurs mots, de sorte que les Group objets contiennent uniquement des informations sur la dernière sous-expression correspondante. Le groupe 1, qui représente la première capture, contient le dernier mot de la phrase qui a une période de fermeture. Le groupe 2, qui représente la deuxième capture, contient le dernier mot de la phrase. Toutefois, les Capture objets de l’objet du CaptureCollection groupe capturent chaque correspondance de sous-expression. Les Capture objets de la première collection de captures du groupe de captures contiennent des informations sur chaque mot capturé et chaque espace blanc ou point. Les Capture objets de la deuxième collection de captures du groupe de captures contiennent des informations sur chaque mot capturé.

Remarques

Un Capture objet est immuable et n’a aucun constructeur public. Les instances sont retournées via l’objetCaptureCollection, qui est retourné par les propriétés et Group.Captures les Match.Captures propriétés. Toutefois, la Match.Captures propriété fournit des informations sur la même correspondance que l’objet Match .

Si vous n’appliquez pas de quantificateur à un groupe de capture, la Group.Captures propriété retourne un CaptureCollection objet unique Capture qui fournit des informations sur la même capture que l’objet Group . Si vous appliquez un quantificateur à un groupe de capture, les propriétés et Group.Value les Group.Index``Group.Lengthpropriétés fournissent des informations uniquement sur le dernier groupe capturé, tandis que les Capture objets dans le CaptureCollection groupe fournissent des informations sur toutes les captures de sous-expression. Cet exemple en fournit une illustration.

Propriétés

Index	Position dans la chaîne d'origine où se trouve le premier caractère de la sous-chaîne capturée.
Length	Obtient la longueur de la sous-chaîne capturée.
Value	Obtient la sous-chaîne capturée à partir de la chaîne d'entrée.
ValueSpan	Obtient l’étendue capturée à partir de la chaîne d’entrée.

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)
ToString()	Récupère la sous-chaîne capturée de la chaîne d'entrée en appelant la propriété Value.

S’applique à

Voir aussi

CaptureCollection