Capture.Value Propriedade

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Origem:: Capture.cs

Origem:: Capture.cs

Origem:: Capture.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Obtém a subcadeia de caracteres capturada da cadeia de caracteres de entrada.

public:
 property System::String ^ Value { System::String ^ get(); };

public string Value { get; }

member this.Value : string

Public ReadOnly Property Value As String

Valor da propriedade

String

A subcadeia de caracteres capturada pela correspondência.

Exemplos

O exemplo a seguir define uma expressão regular que corresponde a frases que não contêm pontuação, exceto por um ponto ("."). A Match.Value propriedade exibe a cadeia de caracteres de resultado, que consiste em uma frase correspondente, para cada correspondência. A Group.Value propriedade exibe a cadeia de caracteres de resultado para cada grupo de captura; ela consiste na última cadeia de caracteres capturada por esse grupo de captura. A Capture.Value propriedade exibe a cadeia de caracteres de resultado para cada captura.

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 de espaço em branco ou ponto (".").
`((\w+)[\s.])`	Corresponder a um ou mais caracteres de palavra seguidos por um caractere de espaço em branco ou ponto final ("."). Este é o primeiro grupo de captura.
`((\w+)[\s.])+`	Corresponde a uma ou mais ocorrências de um caractere de palavra ou caracteres seguidos por um caractere de espaço em branco ou ponto (".").

Neste exemplo, a cadeia de caracteres de entrada consiste em duas frases. Como mostra a saída, 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 subexpressão correspondente. Os Capture objetos na coleção de capturas do primeiro grupo de captura contêm informações sobre cada palavra capturada e caractere de espaço em branco ou ponto. Os Capture objetos na coleção de capturas do segundo grupo de captura contêm informações sobre cada palavra capturada.

O exemplo a seguir usa um padrão de expressão regular, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$, para corresponder a um número de produto que consiste em duas partes separadas por um período. Ambas as partes consistem em caracteres alfabéticos seguidos por números opcionais. Como a primeira cadeia de caracteres de entrada não corresponde ao padrão, o valor da propriedade do Value objeto retornado System.Text.RegularExpressions.Match é String.Empty. Da mesma forma, quando o padrão de expressão regular não consegue corresponder a um grupo de captura, o valor da propriedade do Value objeto correspondente Group é String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String pattern = @"^([a-z]+)(\d+)?\.([a-z]+(\d)*)$";
      String[] values = { "AC10", "Za203.CYM", "XYZ.CoA", "ABC.x170" };   
      foreach (var value in values) {
         Match m = Regex.Match(value, pattern, RegexOptions.IgnoreCase);
         if (m.Success) {
            Console.WriteLine("Match: '{0}'", m.Value);
            Console.WriteLine("   Number of Capturing Groups: {0}", 
                              m.Groups.Count);
            for (int gCtr = 0; gCtr < m.Groups.Count; gCtr++) {
               Group group = m.Groups[gCtr];
               Console.WriteLine("      Group {0}: {1}", gCtr, 
                                 group.Value == "" ? "<empty>" : "'" + group.Value + "'");   
               Console.WriteLine("         Number of Captures: {0}", 
                                 group.Captures.Count);
           
               for (int cCtr = 0; cCtr < group.Captures.Count; cCtr++) 
                  Console.WriteLine("            Capture {0}: {1}", 
                                    cCtr, group.Captures[cCtr].Value);
            }
         } 
         else {
            Console.WriteLine("No match for {0}: Match.Value is {1}", 
                              value, m.Value == String.Empty ? "<empty>" : m.Value);
         }
      }
   }
}
// The example displays the following output:
//       No match for AC10: Match.Value is <empty>
//       Match: 'Za203.CYM'
//          Number of Capturing Groups: 5
//             Group 0: 'Za203.CYM'
//                Number of Captures: 1
//                   Capture 0: Za203.CYM
//             Group 1: 'Za'
//                Number of Captures: 1
//                   Capture 0: Za
//             Group 2: '203'
//                Number of Captures: 1
//                   Capture 0: 203
//             Group 3: 'CYM'
//                Number of Captures: 1
//                   Capture 0: CYM
//             Group 4: <empty>
//                Number of Captures: 0
//       Match: 'XYZ.CoA'
//          Number of Capturing Groups: 5
//             Group 0: 'XYZ.CoA'
//                Number of Captures: 1
//                   Capture 0: XYZ.CoA
//             Group 1: 'XYZ'
//                Number of Captures: 1
//                   Capture 0: XYZ
//             Group 2: <empty>
//                Number of Captures: 0
//             Group 3: 'CoA'
//                Number of Captures: 1
//                   Capture 0: CoA
//             Group 4: <empty>
//                Number of Captures: 0
//       Match: 'ABC.x170'
//          Number of Capturing Groups: 5
//             Group 0: 'ABC.x170'
//                Number of Captures: 1
//                   Capture 0: ABC.x170
//             Group 1: 'ABC'
//                Number of Captures: 1
//                   Capture 0: ABC
//             Group 2: <empty>
//                Number of Captures: 0
//             Group 3: 'x170'
//                Number of Captures: 1
//                   Capture 0: x170
//             Group 4: '0'
//                Number of Captures: 3
//                   Capture 0: 1
//                   Capture 1: 7
//                   Capture 2: 0

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^([a-z]+)(\d+)?\.([a-z]+(\d)*)$"
      Dim values() As String = { "AC10", "Za203.CYM", "XYZ.CoA", "ABC.x170" }   
      For Each value In values
         Dim m As Match = Regex.Match(value, pattern, RegexOptions.IgnoreCase)
         If m.Success Then
            Console.WriteLine("Match: '{0}'", m.Value)
            Console.WriteLine("   Number of Capturing Groups: {0}", 
                              m.Groups.Count)
            For gCtr As Integer = 0 To m.Groups.Count - 1
               Dim group As Group = m.Groups(gCtr)
               Console.WriteLine("      Group {0}: {1}", gCtr, 
                                 If(group.Value = "", "<empty>", "'" + group.Value + "'"))   
               Console.WriteLine("         Number of Captures: {0}", 
                                 group.Captures.Count)
           
               For cCtr As Integer = 0 To group.Captures.Count - 1
                  Console.WriteLine("            Capture {0}: {1}", 
                                    cCtr, group.Captures(cCtr).Value)
               Next
            Next
         Else
            Console.WriteLine("No match for {0}: Match.Value is {1}", 
                              value, If(m.Value = String.Empty, "<empty>", m.Value))
         End If
      Next    
   End Sub
End Module
' The example displays the following output:
'       No match for AC10: Match.Value is <empty>
'       Match: 'Za203.CYM'
'          Number of Capturing Groups: 5
'             Group 0: 'Za203.CYM'
'                Number of Captures: 1
'                   Capture 0: Za203.CYM
'             Group 1: 'Za'
'                Number of Captures: 1
'                   Capture 0: Za
'             Group 2: '203'
'                Number of Captures: 1
'                   Capture 0: 203
'             Group 3: 'CYM'
'                Number of Captures: 1
'                   Capture 0: CYM
'             Group 4: <empty>
'                Number of Captures: 0
'       Match: 'XYZ.CoA'
'          Number of Capturing Groups: 5
'             Group 0: 'XYZ.CoA'
'                Number of Captures: 1
'                   Capture 0: XYZ.CoA
'             Group 1: 'XYZ'
'                Number of Captures: 1
'                   Capture 0: XYZ
'             Group 2: <empty>
'                Number of Captures: 0
'             Group 3: 'CoA'
'                Number of Captures: 1
'                   Capture 0: CoA
'             Group 4: <empty>
'                Number of Captures: 0
'       Match: 'ABC.x170'
'          Number of Capturing Groups: 5
'             Group 0: 'ABC.x170'
'                Number of Captures: 1
'                   Capture 0: ABC.x170
'             Group 1: 'ABC'
'                Number of Captures: 1
'                   Capture 0: ABC
'             Group 2: <empty>
'                Number of Captures: 0
'             Group 3: 'x170'
'                Number of Captures: 1
'                   Capture 0: x170
'             Group 4: '0'
'                Number of Captures: 3
'                   Capture 0: 1
'                   Capture 1: 7
'                   Capture 2: 0

O padrão de expressão regular é definido conforme mostrado na tabela a seguir:

Padrão	Descrição
`^`	Começar a correspondência no início da cadeia de caracteres.
`([a-z]+)`	Corresponde a uma ou mais ocorrências de qualquer caractere de a a z. Como o mecanismo de expressão regular recebe a opção RegexOptions.IgnoreCase , essa comparação não diferencia maiúsculas de minúsculas. Este é o primeiro grupo de captura.
`(\d+)?`	Corresponde a zero ou uma ocorrência de um ou mais dígitos decimais. Este é o segundo grupo de captura.
`\.`	Corresponder a um caractere de ponto literal.
`([a-z]+`	Corresponde a uma ou mais ocorrências de qualquer caractere de a a z. A comparação não diferencia maiúsculas de minúsculas.
`(\d)*`	Corresponde a zero ou mais dígitos decimais. Um único dígito correspondente é o quarto grupo de captura.
`([a-z]+(\d)*)`	Corresponde a um ou mais caracteres alfabéticos de a z seguidos por zero, um ou mais dígitos decimais. Este é o quarto grupo de captura.
`$`	Conclua a correspondência no final da cadeia de caracteres.

Comentários

Se uma chamada para o Regex.Match método ou Match.NextMatch não encontrar uma correspondência, o valor da propriedade retornada Match.Value será String.Empty. Se o mecanismo de expressão regular não conseguir corresponder a um grupo de captura. o valor da propriedade retornada Group.Value é String.Empty. Confira o segundo exemplo para obter uma ilustração.

Aplica-se a

Compartilhar via