Capture Classe

Definição

Namespace:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Assembly:

System.dll

Assembly:

netstandard.dll

Representa os resultados de uma única captura de subexpressão bem-sucedida.

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.

Padrão	Descrição
(\w+)	Fazer a correspondência a um ou mais caracteres de palavra. Este é o segundo grupo de captura.
[\s.])	Corresponder a um caractere ou ponto de espaço em branco (".").
((\w+)[\s.])	Corresponder a um ou mais caracteres de palavra seguidos por um caractere de espaço em branco ou ponto ("."). Este é o primeiro grupo de captura.
((\w+)[\s.])+	Corresponder a uma ou mais ocorrências de um caractere de palavra ou caracteres seguidos por um caractere de espaço em branco ou período (".").

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

Index	A posição na cadeia de caracteres original em que foi encontrado o primeiro caractere da subcadeia capturada.
Length	Obtém o comprimento da subcadeia de caracteres capturada.
Value	Obtém a subcadeia de caracteres capturada da cadeia de caracteres de entrada.
ValueSpan	Obtém o intervalo capturado da cadeia de caracteres de entrada.

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Recupera a subcadeia de caracteres capturada da cadeia de entrada chamando a propriedade Value.

Confira também

• CaptureCollection