Group 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 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: Object

Capture
Group

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

Attributs: SerializableAttribute

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 à

Partager via