Group Clase

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Representa los resultados de un único grupo de captura.

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

Herencia: Object

Capture
Group

Derivado: System.Text.RegularExpressions.Match

Atributos: SerializableAttribute

Comentarios

Un grupo de captura puede capturar cero, una o más cadenas en una sola coincidencia debido a cuantificadores. (Para obtener más información, vea Cuantificadores). Todas las subcadenas coincidentes con un único grupo de captura están disponibles en la Group.Captures propiedad . Se puede acceder directamente a la información sobre la última subcadena capturada desde las Value propiedades y Index . (Es decir, la Group instancia es equivalente al último elemento de la colección devuelta por la Captures propiedad , que refleja la última captura realizada por el grupo de captura).

Un ejemplo ayuda a aclarar esta relación entre un Group objeto y el System.Text.RegularExpressions.CaptureCollection devuelto por la Captures propiedad . El patrón (\b(\w+?)[,:;]?\s?)+[?.!] de expresión regular coincide con oraciones completas. La expresión regular se define como se muestra en la tabla siguiente.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`(\w+?)`	Coincide con uno o más caracteres de palabra, pero con el menor número de caracteres posible. Este es el segundo grupo de captura (interno). (El primer grupo de captura incluye el `\b` elemento language).
`[,:;]?`	Coincide con cero o una aparición de una coma, dos puntos o punto y coma.
`\s?`	Coincide con cero o una aparición de un carácter de espacio en blanco.
`(\b(\w+?)[,:;]?\s?)+`	Coincide con el patrón que consta de un límite de palabra, uno o varios caracteres de palabra, un símbolo de puntuación y un carácter de espacio en blanco una o varias veces. Este es el primer grupo de captura.
`[?.!]`	Coincide con cualquier aparición de un punto, signo de interrogación o signo de exclamación.

En este patrón de expresión regular, el subpattern (\w+?) está diseñado para coincidir con varias palabras dentro de una oración. Sin embargo, el valor del Group objeto representa solo la última coincidencia que (\w+?) captura, mientras que la Captures propiedad devuelve un CaptureCollection que representa todo el texto capturado. Como se muestra en la salida, el CaptureCollection para el segundo grupo de captura contiene cuatro objetos. La última de estas corresponde al Group objeto .

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'

Propiedades

Captures	Obtiene una colección de todas las capturas que coinciden con el grupo de captura, en orden empezando por el más interno de la izquierda (o por el más interno de la derecha si se modifica con la opción RightToLeft). La colección puede tener cero o más elementos.
Index	Posición en la cadena original donde se encuentra el primer carácter de la subcadena capturada. (Heredado de Capture)
Length	Obtiene la longitud de la subcadena capturada. (Heredado de Capture)
Name	Devuelve el nombre del grupo de captura que la instancia actual representa.
Success	Obtiene un valor que indica si la coincidencia ha tenido éxito.
Value	Obtiene la subcadena capturada desde la cadena de entrada. (Heredado de Capture)
ValueSpan	Obtiene el intervalo capturado de la cadena de entrada. (Heredado de Capture)

Métodos

Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
Synchronized(Group)	Devuelve un objeto `Group` equivalente al suministrado que puede compartirse con seguridad entre varios subprocesos.
ToString()	Recupera la subcadena capturada de la cadena de entrada llamando a la propiedad Value. (Heredado de Capture)

Se aplica a

Compartir a través de