Capture Clase

Definición

public ref class Capture

public class Capture

[System.Serializable]
public class Capture

type Capture = class

[<System.Serializable>]
type Capture = class

Public Class Capture

Herencia

Object

Capture

Derivado

System.Text.RegularExpressions.Group

Atributos

SerializableAttribute

Ejemplos

En el ejemplo siguiente se define una expresión regular que coincide con las oraciones que no contienen signos de puntuación excepto un punto (".").

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

El patrón de expresión regular ((\w+)[\s.])+ se define como se muestra en la tabla siguiente. Tenga en cuenta que, en esta expresión regular, se aplica un cuantificador (+) a toda la expresión regular.

En este ejemplo, la cadena de entrada consta de dos oraciones. Como se muestra en la salida, la primera oración consta de una sola palabra, por lo que el CaptureCollection objeto tiene un solo Capture objeto que representa la misma captura que el Group objeto . La segunda oración consta de varias palabras, por lo que los Group objetos solo contienen información sobre la última subexpresión coincidente. El grupo 1, que representa la primera captura, contiene la última palabra de la frase que tiene un período de cierre. El grupo 2, que representa la segunda captura, contiene la última palabra de la oración. Sin embargo, los Capture objetos del objeto del CaptureCollection grupo capturan cada coincidencia de subexpresión. Los Capture objetos de la primera colección de capturas del grupo de capturas contienen información sobre cada palabra capturada y el carácter o punto de espacio en blanco. Los Capture objetos de la segunda colección de capturas del grupo de capturas contienen información sobre cada palabra capturada.

Comentarios

Un Capture objeto es inmutable y no tiene ningún constructor público. Las instancias se devuelven a través del CaptureCollection objeto , que devuelven las Match.Captures propiedades y Group.Captures . Sin embargo, la Match.Captures propiedad proporciona información sobre la misma coincidencia que el Match objeto .

Si no aplica un cuantificador a un grupo de captura, la Group.Captures propiedad devuelve un CaptureCollection con un único Capture objeto que proporciona información sobre la misma captura que el Group objeto. Si aplica un cuantificador a un grupo de captura, las Group.Indexpropiedades , Group.Lengthy Group.Value proporcionan información solo sobre el último grupo capturado, mientras que los Capture objetos de proporcionan CaptureCollection información sobre todas las capturas de subexpresión. En este ejemplo se ilustra.

Propiedades

Métodos

Se aplica a

Consulte también

• CaptureCollection