Capture Classe

Definição

public ref class Capture

public class Capture

[System.Serializable]
public class Capture

type Capture = class

[<System.Serializable>]
type Capture = class

Public Class Capture

Herança

Object

Capture

Derivado

System.Text.RegularExpressions.Group

Atributos

SerializableAttribute

Exemplos

O exemplo a seguir define uma expressão regular que corresponde a frases que não contêm pontuação, exceto por um período (".").

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

O padrão de expressão regular ((\w+)[\s.])+ é definido conforme mostrado na tabela a seguir. Observe que, nessa expressão regular, um quantificador (+) é aplicado a toda a expressão regular.

Neste exemplo, a cadeia de caracteres de entrada consiste em duas frases. Como a saída mostra, a primeira frase consiste em apenas uma palavra, portanto, o CaptureCollection objeto tem um único Capture objeto que representa a mesma captura que o Group objeto. A segunda frase consiste em várias palavras, portanto, os Group objetos contêm apenas informações sobre a última subexpressão correspondente. O grupo 1, que representa a primeira captura, contém a última palavra na frase que tem um período de fechamento. O grupo 2, que representa a segunda captura, contém a última palavra na frase. No entanto, os Capture objetos no objeto do CaptureCollection grupo capturam cada correspondência de subexpressão. Os Capture objetos na coleção de capturas do primeiro grupo de captura contêm informações sobre cada palavra capturada e caractere ou período de espaço em branco. Os Capture objetos na coleção de capturas do segundo grupo de captura contêm informações sobre cada palavra capturada.

Comentários

Um Capture objeto é imutável e não tem construtor público. As instâncias são retornadas por meio do CaptureCollection objeto , que é retornado pelas Match.Captures propriedades e Group.Captures . No entanto, a Match.Captures propriedade fornece informações sobre a mesma correspondência que o Match objeto .

Se você não aplicar um quantificador a um grupo de captura, a Group.Captures propriedade retornará um CaptureCollection com um único Capture objeto que fornece informações sobre a mesma captura que o Group objeto. Se você aplicar um quantificador a um grupo de captura, as Group.Indexpropriedades , Group.Lengthe Group.Value fornecerão informações apenas sobre o último grupo capturado, enquanto os Capture objetos no CaptureCollection fornecem informações sobre todas as capturas de subexpressão. O exemplo fornece uma ilustração.

Propriedades

Métodos

Aplica-se a

Confira também

• CaptureCollection