Partager via


Group Classe

Définition

Représente les résultats d'un groupe de capture spécifique.

public ref class Group : System::Text::RegularExpressions::Capture
public class Group : System.Text.RegularExpressions.Capture
[System.Serializable]
public class Group : System.Text.RegularExpressions.Capture
type Group = class
    inherit Capture
[<System.Serializable>]
type Group = class
    inherit Capture
Public Class Group
Inherits Capture
Héritage
Group
Dérivé
Attributs

Remarques

Un groupe de capture peut capturer zéro, un ou plusieurs chaînes dans une correspondance unique en raison de quantificateurs. (Pour plus d’informations, consultez Quantificateurs.) Toutes les sous-chaînes mises en correspondance par un seul groupe de capture sont disponibles à partir de la Group.Captures propriété. Les informations sur la dernière sous-chaîne capturée sont accessibles directement à partir des propriétés et Index des Value propriétés. (Autrement dit, l’instance Group équivaut au dernier élément de la collection retourné par la Captures propriété, qui reflète la dernière capture effectuée par le groupe de capture.)

Un exemple permet de clarifier cette relation entre un Group objet et celle System.Text.RegularExpressions.CaptureCollection retournée par la Captures propriété. Le modèle (\b(\w+?)[,:;]?\s?)+[?.!] d’expression régulière correspond à des phrases entières. L'expression régulière est définie comme indiqué dans le tableau suivant.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
(\w+?) Correspond à un ou plusieurs caractères alphabétiques, mais le moins de caractères possible. Il s’agit du deuxième groupe de capture (interne). (Le premier groupe de capture inclut l’élément \b de langue.)
[,:;]? Correspond à zéro ou à une occurrence d’une virgule, d’un point-virgule ou d’un point-virgule.
\s? Correspond à zéro ou à une occurrence d’un caractère d’espace blanc.
(\b(\w+?)[,:;]?\s?)+ Correspond au modèle constitué d’une limite de mot, d’un ou plusieurs caractères de mot, d’un symbole de ponctuation et d’un caractère d’espace blanc un ou plusieurs fois. Il s'agit du premier groupe de capture.
[?.!] Correspond à n’importe quelle occurrence d’un point d’interrogation, d’un point d’exclamation ou d’un point d’exclamation.

Dans ce modèle d’expression régulière, le sous-objet (\w+?) est conçu pour correspondre à plusieurs mots dans une phrase. Toutefois, la valeur de l’objet Group représente uniquement la dernière correspondance qui (\w+?) capture, tandis que la Captures propriété retourne un CaptureCollection texte capturé. Comme le montre la sortie, le CaptureCollection deuxième groupe de capture contient quatre objets. Le dernier de ces éléments correspond à l’objet Group .

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+?)[,:;]?\s?)+[?.!]";
      string input = "This is one sentence. This is a second sentence.";

      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: " + match.Value);
      int groupCtr = 0;
      foreach (Group group in match.Groups)
      {
         groupCtr++;
         Console.WriteLine("   Group {0}: '{1}'", groupCtr, group.Value);
         int captureCtr = 0;
         foreach (Capture capture in group.Captures)
         {
            captureCtr++;
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, capture.Value);
         }
      }   
   }
}
// The example displays the following output:
//       Match: This is one sentence.
//          Group 1: 'This is one sentence.'
//             Capture 1: 'This is one sentence.'
//          Group 2: 'sentence'
//             Capture 1: 'This '
//             Capture 2: 'is '
//             Capture 3: 'one '
//             Capture 4: 'sentence'
//          Group 3: 'sentence'
//             Capture 1: 'This'
//             Capture 2: 'is'
//             Capture 3: 'one'
//             Capture 4: 'sentence'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+?)[,:;]?\s?)+[?.!]"
      Dim input As String = "This is one sentence. This is a second sentence."

      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: " + match.Value)
      Dim groupCtr As Integer = 0
      For Each group As Group In match.Groups
         groupCtr += 1
         Console.WriteLine("   Group {0}: '{1}'", groupCtr, group.Value)
         Dim captureCtr As Integer = 0
         For Each capture As Capture In group.Captures
            captureCtr += 1
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, capture.Value)
         Next
      Next   
   End Sub
End Module
' The example displays the following output:
'       Match: This is one sentence.
'          Group 1: 'This is one sentence.'
'             Capture 1: 'This is one sentence.'
'          Group 2: 'sentence'
'             Capture 1: 'This '
'             Capture 2: 'is '
'             Capture 3: 'one '
'             Capture 4: 'sentence'
'          Group 3: 'sentence'
'             Capture 1: 'This'
'             Capture 2: 'is'
'             Capture 3: 'one'
'             Capture 4: 'sentence'

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.

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.

Success

Obtient une valeur indiquant si la correspondance est réussie.

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)
Synchronized(Group)

Retourne un objet Group équivalant à celui qui est fourni, dont le partage entre plusieurs threads est sécurisé.

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)

S’applique à