Capture Classe

Définition

Représente le résultat d'une capture de sous-expression unique ayant réussi.Represents the results from a single successful subexpression capture.

public ref class Capture
[System.Serializable]
public class Capture
type Capture = class
Public Class Capture
Héritage
Capture
Dérivé
Attributs

Exemples

L’exemple suivant définit une expression régulière qui correspond à des phrases qui ne contiennent pas de ponctuation, à l’exception d’un point (".").The following example defines a regular expression that matches sentences that contain no punctuation except for a period (".").

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.The regular expression pattern ((\w+)[\s.])+ is defined as shown in the following table. Notez que dans cette expression régulière, un quantificateur (+) est appliqué à l’intégralité de l’expression régulière.Note that in this regular expression, a quantifier (+) is applied to the entire regular expression.

MotifPattern DescriptionDescription
(\w+) Mettre en correspondance un ou plusieurs caractères alphabétiques.Match one or more word characters. Il s'agit du deuxième groupe de capture.This is the second capturing group.
[\s.]) Correspond à un espace blanc ou à un point (".").Match a white-space character or period (".").
((\w+)[\s.]) Correspond à un ou plusieurs caractères alphabétiques suivis d’un espace blanc ou d’un point (".").Match one or more word characters followed by a white-space character or period ("."). Il s'agit du premier groupe de capture.This is the first capturing group.
((\w+)[\s.])+ Correspond à une ou plusieurs occurrences d’un ou de plusieurs caractères de mot suivis d’un espace blanc ou d’un point (".").Match one or more occurrences of a word character or characters followed by a white-space character or period (".").

Dans cet exemple, la chaîne d’entrée se compose de deux phrases.In this example, the input string consists of two sentences. Comme le montre la sortie, la première phrase est constituée d’un seul mot. par conséquent, l’objet CaptureCollection a un seul objet Capture qui représente la même capture que l’objet Group.As the output shows, the first sentence consists of only one word, so the CaptureCollection object has a single Capture object that represents the same capture as the Group object. La deuxième phrase est constituée de plusieurs mots, donc les objets Group contiennent uniquement des informations sur la dernière sous-expression mise en correspondance.The second sentence consists of multiple words, so the Group objects only contain information about the last matched subexpression. Le groupe 1, qui représente la première capture, contient le dernier mot de la phrase qui a une période de fermeture.Group 1, which represents the first capture, contains the last word in the sentence that has a closing period. Le groupe 2, qui représente la deuxième capture, contient le dernier mot de la phrase.Group 2, which represents the second capture, contains the last word in the sentence. Toutefois, les objets Capture dans l’objet CaptureCollection du groupe capturent chaque correspondance de sous-expression.However, the Capture objects in the group's CaptureCollection object capture each subexpression match. Les objets Capture dans la collection de captures du premier groupe de capture contiennent des informations sur chaque mot capturé et espace blanc ou point.The Capture objects in the first capturing group's collection of captures contain information about each captured word and white-space character or period. Les objets Capture dans la collection de captures du deuxième groupe de capture contiennent des informations sur chaque mot capturé.The Capture objects in the second capturing group's collection of captures contain information about each captured word.

Remarques

Un objet Capture est immuable et n’a pas de constructeur public.A Capture object is immutable and has no public constructor. Les instances sont retournées par l’objet CaptureCollection, qui est retourné par les propriétés Match.Captures et Group.Captures.Instances are returned through the CaptureCollection object, which is returned by the Match.Captures and Group.Captures properties. Toutefois, la propriété Match.Captures fournit des informations sur la même correspondance que l’objet Match.However, the Match.Captures property provides information about the same match as the Match object.

Si vous n’appliquez pas de quantificateur à un groupe de capture, la propriété Group.Captures retourne un CaptureCollection avec un objet Capture unique qui fournit des informations sur la même capture que l’objet Group.If you do not apply a quantifier to a capturing group, the Group.Captures property returns a CaptureCollection with a single Capture object that provides information about the same capture as the Group object. Si vous appliquez un quantificateur à un groupe de capture, les propriétés Group.Index, Group.Lengthet Group.Value fournissent des informations uniquement sur le dernier groupe capturé, alors que les objets Capture dans le CaptureCollection fournissent des informations sur toutes les captures de sous-expression.If you do apply a quantifier to a capturing group, the Group.Index, Group.Length, and Group.Value properties provide information only about the last captured group, whereas the Capture objects in the CaptureCollection provide information about all subexpression captures. Cet exemple en fournit une illustration.The example provides an 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.The position in the original string where the first character of the captured substring is found.

Length

Obtient la longueur de la sous-chaîne capturée.Gets the length of the captured substring.

Value

Obtient la sous-chaîne capturée à partir de la chaîne d'entrée.Gets the captured substring from the input string.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(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.Retrieves the captured substring from the input string by calling the Value property.

S’applique à

Voir aussi