O modelo de objeto de expressão regular

Este artigo descreve o modelo de objeto usado no trabalho com expressões regulares do .NET.

O mecanismo de expressão regular

O mecanismo de expressão regular no .NET é representado pela Regex classe. O mecanismo de expressão regular é responsável por analisar e compilar uma expressão regular e por executar operações que correspondam ao padrão de expressão regular com uma cadeia de caracteres de entrada. O mecanismo é o componente central no modelo de objeto de expressão regular do .NET.

Você pode usar o mecanismo de expressão regular de duas maneiras:

• Chamando os métodos estáticos da Regex classe. Os parâmetros do método incluem a cadeia de caracteres de entrada e o padrão de expressão regular. O mecanismo de expressão regular armazena em cache expressões regulares que são usadas em chamadas de método estático, portanto, chamadas repetidas para métodos de expressão regular estática que usam a mesma expressão regular oferecem um desempenho relativamente bom.

• Instanciando um Regex objeto, ou seja, passando uma expressão regular para o construtor de classe. Nesse caso, o objeto é imutável (somente leitura) e representa um mecanismo de expressão regular que está firmemente acoplado Regex a uma única expressão regular. Como as expressões regulares usadas pelas Regex instâncias não são armazenadas em cache, você não deve instanciar um Regex objeto várias vezes com a mesma expressão regular.

Você pode chamar os métodos da Regex classe para executar as seguintes operações:

• Determine se uma cadeia de caracteres corresponde a um padrão de expressão regular.
• Extraia uma única correspondência ou a primeira correspondência.
• Extraia todas as correspondências.
• Substitua uma subcadeia de caracteres correspondente.
• Divida uma única cadeia de caracteres em uma matriz de cadeias de caracteres.

Essas operações são descritas nas seções a seguir.

Corresponder a um padrão de expressão regular

O Regex.IsMatch método retorna true se a cadeia de caracteres corresponde ao padrão ou false se não corresponder. O IsMatch método é frequentemente usado para validar a entrada de cadeia de caracteres. Por exemplo, o código a seguir garante que uma cadeia de caracteres corresponda a um número de segurança social válido nos Estados Unidos.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "111-22-3333", "111-2-3333"};
      string pattern = @"^\d{3}-\d{2}-\d{4}$";
      foreach (string value in values) {
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("{0} is a valid SSN.", value);
         else
            Console.WriteLine("{0}: Invalid", value);
      }
   }
}
// The example displays the following output:
//       111-22-3333 is a valid SSN.
//       111-2-3333: Invalid

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim values() As String = {"111-22-3333", "111-2-3333"}
        Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
        For Each value As String In values
            If Regex.IsMatch(value, pattern) Then
                Console.WriteLine("{0} is a valid SSN.", value)
            Else
                Console.WriteLine("{0}: Invalid", value)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111-22-3333 is a valid SSN.
'       111-2-3333: Invalid

O padrão ^\d{3}-\d{2}-\d{4}$ de expressão regular é interpretado como mostrado na tabela a seguir.

Extrair uma única correspondência ou a primeira correspondência

O Regex.Match método retorna um Match objeto que contém informações sobre a primeira substring que corresponde a um padrão de expressão regular. Se a Match.Success propriedade retornar true, indicando que uma correspondência foi encontrada, você poderá recuperar informações sobre correspondências subsequentes chamando o Match.NextMatch método. Essas chamadas de método podem continuar até que a Match.Success propriedade retorne false. Por exemplo, o código a seguir usa o Regex.Match(String, String) método para localizar a primeira ocorrência de uma palavra duplicada em uma cadeia de caracteres. Em seguida, ele chama o Match.NextMatch método para localizar quaisquer ocorrências adicionais. O exemplo examina a Match.Success propriedade após cada chamada de método para determinar se a correspondência atual foi bem-sucedida e se uma chamada para o Match.NextMatch método deve seguir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("Duplicate '{0}' found at position {1}.",
                           match.Groups[1].Value, match.Groups[2].Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

O padrão \b(\w+)\W+(\1)\b de expressão regular é interpretado como mostrado na tabela a seguir.

Extrair todas as correspondências

O Regex.Matches método retorna um MatchCollection objeto que contém informações sobre todas as correspondências que o mecanismo de expressão regular encontrou na cadeia de caracteres de entrada. Por exemplo, o exemplo anterior pode ser reescrito para chamar o Matches método em vez dos Match métodos e NextMatch .

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Duplicate '{0}' found at position {1}.",
                           match.Groups[1].Value, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

Substituir uma substring correspondente

O Regex.Replace método substitui cada substring que corresponde ao padrão de expressão regular por uma string especificada ou padrão de expressão regular e retorna toda a string de entrada com substituições. Por exemplo, o código a seguir adiciona um símbolo de moeda dos EUA antes de um número decimal em uma cadeia de caracteres.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+\.\d{2}\b";
      string replacement = "$$$&";
      string input = "Total Cost: 103.64";
      Console.WriteLine(Regex.Replace(input, pattern, replacement));
   }
}
// The example displays the following output:
//       Total Cost: $103.64

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+\.\d{2}\b"
        Dim replacement As String = "$$$&"
        Dim input As String = "Total Cost: 103.64"
        Console.WriteLine(Regex.Replace(input, pattern, replacement))
    End Sub
End Module
' The example displays the following output:
'       Total Cost: $103.64

O padrão \b\d+\.\d{2}\b de expressão regular é interpretado como mostrado na tabela a seguir.

O padrão $$$& de substituição é interpretado como mostrado na tabela a seguir.

Dividir uma única cadeia de caracteres em uma matriz de cadeias de caracteres

O Regex.Split método divide a cadeia de caracteres de entrada nas posições definidas por uma correspondência de expressão regular. Por exemplo, o código a seguir coloca os itens em uma lista numerada em uma matriz de cadeia de caracteres.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
      string pattern = @"\b\d{1,2}\.\s";
      foreach (string item in Regex.Split(input, pattern))
      {
         if (! String.IsNullOrEmpty(item))
            Console.WriteLine(item);
      }
   }
}
// The example displays the following output:
//       Eggs
//       Bread
//       Milk
//       Coffee
//       Tea

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
        Dim pattern As String = "\b\d{1,2}\.\s"
        For Each item As String In Regex.Split(input, pattern)
            If Not String.IsNullOrEmpty(item) Then
                Console.WriteLine(item)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Eggs
'       Bread
'       Milk
'       Coffee
'       Tea

O padrão \b\d{1,2}\.\s de expressão regular é interpretado como mostrado na tabela a seguir.

O MatchCollection e Match objetos

Os métodos Regex retornam dois objetos que fazem parte do modelo de objeto de expressão regular: o MatchCollection objeto e o Match objeto.

A MatchCollection classe

O Regex.Matches método retorna um MatchCollection objeto que contém Match objetos que representam todas as correspondências que o mecanismo de expressão regular encontrou, na ordem em que ocorrem na cadeia de caracteres de entrada. Se não houver correspondências, o método retornará um MatchCollection objeto sem membros. A MatchCollection.Item[] propriedade permite acessar membros individuais da coleção por índice, de zero a um a menos do que o valor da MatchCollection.Count propriedade. Item[] é o indexador da coleção (em C#) e a propriedade padrão (no Visual Basic).

Por padrão, a chamada para o método usa avaliação lenta Regex.Matches para preencher o MatchCollection objeto. O acesso a propriedades que exigem uma coleção totalmente preenchida, como as MatchCollection.Count propriedades e MatchCollection.Item[] , pode envolver uma penalidade de desempenho. Como resultado, recomendamos que você acesse a coleção usando o IEnumerator objeto retornado pelo MatchCollection.GetEnumerator método. Linguagens individuais fornecem construções, como For Each em Visual Basic e foreach em C#, que envolvem a interface da IEnumerator coleção.

O exemplo a seguir usa o Regex.Matches(String) método para preencher um MatchCollection objeto com todas as correspondências encontradas em uma cadeia de caracteres de entrada. O exemplo enumera a coleção, copia as correspondências para uma matriz de cadeia de caracteres e registra as posições de caracteres em uma matriz inteira.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
       MatchCollection matches;
       List<string> results = new List<string>();
       List<int> matchposition = new List<int>();

       // Create a new Regex object and define the regular expression.
       Regex r = new Regex("abc");
       // Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd");
       // Enumerate the collection to retrieve all matches and positions.
       foreach (Match match in matches)
       {
          // Add the match string to the string array.
           results.Add(match.Value);
           // Record the character position where the match was found.
           matchposition.Add(match.Index);
       }
       // List the results.
       for (int ctr = 0; ctr < results.Count; ctr++)
         Console.WriteLine("'{0}' found at position {1}.",
                           results[ctr], matchposition[ctr]);
   }
}
// The example displays the following output:
//       'abc' found at position 3.
//       'abc' found at position 7.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim matches As MatchCollection
        Dim results As New List(Of String)
        Dim matchposition As New List(Of Integer)

        ' Create a new Regex object and define the regular expression.
        Dim r As New Regex("abc")
        ' Use the Matches method to find all matches in the input string.
        matches = r.Matches("123abc4abcd")
        ' Enumerate the collection to retrieve all matches and positions.
        For Each match As Match In matches
            ' Add the match string to the string array.
            results.Add(match.Value)
            ' Record the character position where the match was found.
            matchposition.Add(match.Index)
        Next
        ' List the results.
        For ctr As Integer = 0 To results.Count - 1
            Console.WriteLine("'{0}' found at position {1}.", _
                              results(ctr), matchposition(ctr))
        Next
    End Sub
End Module
' The example displays the following output:
'       'abc' found at position 3.
'       'abc' found at position 7.

A Match classe

A Match classe representa o resultado de uma única correspondência de expressão regular. Você pode acessar Match objetos de duas maneiras:

• Recuperando-os do MatchCollection objeto que é retornado pelo Regex.Matches método. Para recuperar objetos individuais Match , itere a coleção usando uma foreach construção (em C#) ou For Each...Next (em Visual Basic) ou use a MatchCollection.Item[] propriedade para recuperar um objeto específico Match por índice ou por nome. Você também pode recuperar objetos individuais Match da coleção iterando a coleção por índice, de zero a um a menos que o número de objetos na coleção. No entanto, este método não aproveita a avaliação preguiçosa, pois acede ao MatchCollection.Count imóvel.

  O exemplo a seguir recupera objetos individuais Match de um MatchCollection objeto iterando a coleção usando a foreach construção ou For Each...Next A expressão regular simplesmente corresponde à string "abc" na string de entrada.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "abc";
        string input = "abc123abc456abc789";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine("{0} found at position {1}.",
                             match.Value, match.Index);
     }
  }
  // The example displays the following output:
  //       abc found at position 0.
  //       abc found at position 6.
  //       abc found at position 12.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "abc"
          Dim input As String = "abc123abc456abc789"
          For Each match As Match In Regex.Matches(input, pattern)
              Console.WriteLine("{0} found at position {1}.", _
                                match.Value, match.Index)
          Next
      End Sub
  End Module
  ' The example displays the following output:
  '       abc found at position 0.
  '       abc found at position 6.
  '       abc found at position 12.
  

• Chamando o Regex.Match método, que retorna um Match objeto que representa a primeira correspondência em uma cadeia de caracteres ou uma parte de uma cadeia de caracteres. Você pode determinar se a correspondência foi encontrada recuperando o valor da Match.Success propriedade. Para recuperar Match objetos que representam correspondências subsequentes, chame o Match.NextMatch método repetidamente, até que a Success propriedade do objeto retornado Match seja false.

  O exemplo a seguir usa os Regex.Match(String, String) métodos e Match.NextMatch para corresponder à cadeia de caracteres "abc" na cadeia de caracteres de entrada.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "abc";
        string input = "abc123abc456abc789";
        Match match = Regex.Match(input, pattern);
        while (match.Success)
        {
           Console.WriteLine("{0} found at position {1}.",
                             match.Value, match.Index);
           match = match.NextMatch();
        }
     }
  }
  // The example displays the following output:
  //       abc found at position 0.
  //       abc found at position 6.
  //       abc found at position 12.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "abc"
          Dim input As String = "abc123abc456abc789"
          Dim match As Match = Regex.Match(input, pattern)
          Do While match.Success
              Console.WriteLine("{0} found at position {1}.", _
                                match.Value, match.Index)
              match = match.NextMatch()
          Loop
      End Sub
  End Module
  ' The example displays the following output:
  '       abc found at position 0.
  '       abc found at position 6.
  '       abc found at position 12.
  

Duas propriedades da Match classe retornam objetos de coleção:

• A Match.Groups propriedade retorna um GroupCollection objeto que contém informações sobre as substrings que correspondem à captura de grupos no padrão de expressão regular.

• A Match.Captures propriedade retorna um CaptureCollection objeto que é de uso limitado. A coleção não é preenchida para um Match objeto cuja Success propriedade é false. Caso contrário, ele contém um único Capture objeto que tem as mesmas informações que o Match objeto.

Para obter mais informações sobre esses objetos, consulte As seções A GroupCollection classe e A CaptureCollection classe mais adiante neste artigo.

Duas propriedades adicionais da Match classe fornecem informações sobre a correspondência. A Match.Value propriedade retorna a substring na cadeia de caracteres de entrada que corresponde ao padrão de expressão regular. A Match.Index propriedade retorna a posição inicial baseada em zero da cadeia de caracteres correspondente na cadeia de caracteres de entrada.

A Match classe também tem dois métodos de correspondência de padrões:

• O Match.NextMatch método localiza a correspondência após a correspondência representada pelo objeto atual Match e retorna um Match objeto que representa essa correspondência.

• O Match.Result método executa uma operação de substituição especificada na cadeia de caracteres correspondente e retorna o resultado.

O exemplo a seguir usa o Match.Result método para preceder um símbolo $ e um espaço antes de cada número que inclui dois dígitos fracionários.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
      string input = "16.32\n194.03\n1,903,672.08";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Result("$$ $&"));
   }
}
// The example displays the following output:
//       $ 16.32
//       $ 194.03
//       $ 1,903,672.08

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
        Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Result("$$ $&"))
        Next
    End Sub
End Module
' The example displays the following output:
'       $ 16.32
'       $ 194.03
'       $ 1,903,672.08

O padrão \b\d+(,\d{3})*\.\d{2}\b de expressão regular é definido conforme mostrado na tabela a seguir.

O padrão $$ $& de substituição indica que a substring correspondente deve ser substituída por um símbolo de cifrão ($) (o $$ padrão), um espaço e o valor da correspondência (o $& padrão).

A GroupCollection classe

A Match.Groups propriedade retorna um GroupCollection objeto que contém Group objetos que representam grupos capturados em uma única correspondência. O primeiro Group objeto da coleção (no índice 0) representa toda a correspondência. Cada objeto a seguir representa os resultados de um único grupo de captura.

Você pode recuperar objetos individuais Group na coleção usando a GroupCollection.Item[] propriedade. Você pode recuperar grupos sem nome por sua posição ordinal na coleção e recuperar grupos nomeados por nome ou por posição ordinal. As capturas sem nome aparecem primeiro na coleção e são indexadas da esquerda para a direita na ordem em que aparecem no padrão de expressão regular. As capturas nomeadas são indexadas após capturas sem nome, da esquerda para a direita na ordem em que aparecem no padrão de expressão regular. Para determinar quais grupos numerados estão disponíveis na coleção retornada para um determinado método de correspondência de expressão regular, você pode chamar o método de instância Regex.GetGroupNumbers . Para determinar quais grupos nomeados estão disponíveis na coleção, você pode chamar o método de instância Regex.GetGroupNames . Ambos os métodos são particularmente úteis em rotinas de uso geral que analisam as correspondências encontradas por qualquer expressão regular.

A GroupCollection.Item[] propriedade é o indexador da coleção em C# e a propriedade padrão do objeto de coleção no Visual Basic. Isso significa que objetos individuais Group podem ser acessados por índice (ou por nome, no caso de grupos nomeados) da seguinte maneira:

Group group = match.Groups[ctr];

Dim group As Group = match.Groups(ctr)

O exemplo a seguir define uma expressão regular que usa construções de agrupamento para capturar o mês, dia e ano de uma data.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
      string input = "Born: July 28, 1989";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
         for (int ctr = 0; ctr <  match.Groups.Count; ctr++)
            Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
    }
}
// The example displays the following output:
//       Group 0: July 28, 1989
//       Group 1: July
//       Group 2: 28
//       Group 3: 1989

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
        Dim input As String = "Born: July 28, 1989"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            For ctr As Integer = 0 To match.Groups.Count - 1
                Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Group 0: July 28, 1989
'       Group 1: July
'       Group 2: 28
'       Group 3: 1989

O padrão \b(\w+)\s(\d{1,2}),\s(\d{4})\b de expressão regular é definido conforme mostrado na tabela a seguir.

O grupo capturado

A Group classe representa o resultado de um único grupo de captura. Os objetos de grupo que representam os grupos de captura definidos em uma expressão regular são retornados pela Item[] propriedade do GroupCollection objeto retornado pela Match.Groups propriedade. A Item[] propriedade é o indexador (em C#) e a propriedade padrão (em Visual Basic) da Group classe. Você também pode recuperar membros individuais iterando a coleção usando a foreach construção or For Each . Para um exemplo, consulte a seção anterior.

O exemplo a seguir usa construções de agrupamento aninhadas para capturar substrings em grupos. O padrão (a(b))c de expressão regular corresponde à cadeia de caracteres "abc". Ele atribui a substring "ab" ao primeiro grupo de captura, e a substring "b" ao segundo grupo de captura.

var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
    // Add groups to string array.
    results.Add(m.Groups[i].Value);
    // Record character position.
    matchposition.Add(m.Groups[i].Index);
}

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
    Console.WriteLine("{0} at position {1}",
                      results[ctr], matchposition[ctr]);
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4

Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
    ' Add groups to string array.
    results.Add(m.Groups(i).Value)
    ' Record character position. 
    matchposition.Add(m.Groups(i).Index)
    i += 1
End While

' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
    Console.WriteLine("{0} at position {1}", _
                      results(ctr), matchposition(ctr))
Next
' The example displays the following output:
'       abc at position 3
'       ab at position 3
'       b at position 4

O exemplo a seguir usa construções de agrupamento nomeadas para capturar substrings de uma cadeia de caracteres que contém dados no formato "DATANAME:VALUE", que a expressão regular divide nos dois pontos (:).

var r = new Regex(@"^(?<name>\w+):(?<value>\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
//       Section1
//       119900

Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
'       Section1
'       119900

O padrão ^(?<name>\w+):(?<value>\w+) de expressão regular é definido conforme mostrado na tabela a seguir.

As propriedades da Group classe fornecem informações sobre o grupo capturado: A Group.Value propriedade contém a substring capturada, a Group.Index propriedade indica a posição inicial do grupo capturado no texto de entrada, a Group.Length propriedade contém o comprimento do texto capturado e a Group.Success propriedade indica se uma substring correspondia ao padrão definido pelo grupo de captura.

A aplicação de quantificadores a um grupo (para obter mais informações, consulte Quantificadores) modifica a relação de uma captura por grupo de captura de duas maneiras:

• Se o * quantificador ou *? (que especifica zero ou mais correspondências) for aplicado a um grupo, um grupo de captura pode não ter uma correspondência na cadeia de caracteres de entrada. Quando não há texto capturado, as propriedades do Group objeto são definidas conforme mostrado na tabela a seguir.

  Propriedade do grupo	Value
  Success	false
  Value	String.Empty
  Length	0

  O exemplo a seguir fornece uma ilustração. No padrão aaa(bbb)*cccde expressão regular, o primeiro grupo de captura (a substring "bbb") pode ser correspondido zero ou mais vezes. Como a cadeia de caracteres de entrada "aaaccc" corresponde ao padrão, o grupo de captura não tem uma correspondência.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "aaa(bbb)*ccc";
        string input = "aaaccc";
        Match match = Regex.Match(input, pattern);
        Console.WriteLine("Match value: {0}", match.Value);
        if (match.Groups[1].Success)
           Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value);
        else
           Console.WriteLine("The first capturing group has no match.");
     }
  }
  // The example displays the following output:
  //       Match value: aaaccc
  //       The first capturing group has no match.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "aaa(bbb)*ccc"
          Dim input As String = "aaaccc"
          Dim match As Match = Regex.Match(input, pattern)
          Console.WriteLine("Match value: {0}", match.Value)
          If match.Groups(1).Success Then
              Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value)
          Else
              Console.WriteLine("The first capturing group has no match.")
          End If
      End Sub
  End Module
  ' The example displays the following output:
  '       Match value: aaaccc
  '       The first capturing group has no match.
  

• Os quantificadores podem corresponder a várias ocorrências de um padrão definido por um grupo de captura. Nesse caso, as Value propriedades e Length de um Group objeto contêm informações apenas sobre a última subcadeia capturada. Por exemplo, a expressão regular a seguir corresponde a uma única frase que termina em um ponto. Ele usa duas construções de agrupamento: A primeira captura palavras individuais juntamente com um caractere de espaço em branco; o segundo capta palavras individuais. Como mostra a saída do exemplo, embora a expressão regular consiga capturar uma frase inteira, o segundo grupo de captura captura apenas a última palavra.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = @"\b((\w+)\s?)+\.";
        string input = "This is a sentence. This is another sentence.";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
           Console.WriteLine("Match: " + match.Value);
           Console.WriteLine("Group 2: " + match.Groups[2].Value);
        }
     }
  }
  // The example displays the following output:
  //       Match: This is a sentence.
  //       Group 2: sentence
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "\b((\w+)\s?)+\."
          Dim input As String = "This is a sentence. This is another sentence."
          Dim match As Match = Regex.Match(input, pattern)
          If match.Success Then
              Console.WriteLine("Match: " + match.Value)
              Console.WriteLine("Group 2: " + match.Groups(2).Value)
          End If
      End Sub
  End Module
  ' The example displays the following output:
  '       Match: This is a sentence.
  '       Group 2: sentence
  

A CaptureCollection classe

O Group objeto contém informações apenas sobre a última captura. No entanto, todo o conjunto de capturas feitas por um grupo de captura ainda está disponível a partir do CaptureCollection objeto que é retornado pela Group.Captures propriedade. Cada membro da coleção é um Capture objeto que representa uma captura feita por esse grupo de captura, na ordem em que foram capturados (e, portanto, na ordem em que as cadeias de caracteres capturadas foram combinadas da esquerda para a direita na cadeia de entrada). Você pode recuperar objetos individuais Capture da coleção de duas maneiras:

• Iterando através da coleção usando uma construção como foreach (em C#) ou For Each (em Visual Basic).

• Usando a CaptureCollection.Item[] propriedade para recuperar um objeto específico por índice. A Item[] propriedade é a propriedade padrão do CaptureCollection objeto (em Visual Basic) ou indexador (em C#).

Se um quantificador não for aplicado a um grupo de captura, o CaptureCollection objeto conterá um único Capture objeto que é de pouco interesse, porque fornece informações sobre a mesma correspondência que seu Group objeto. Se um quantificador for aplicado a um grupo de captura, o CaptureCollection objeto conterá todas as capturas feitas pelo grupo de captura, e o último membro da coleção representará a mesma captura que o Group objeto.

Por exemplo, se você usar o padrão ((a(b))c)+ de expressão regular (onde o quantificador + especifica uma ou mais correspondências) para capturar correspondências da cadeia de caracteres "abcabcabc", o CaptureCollection objeto para cada Group objeto contém três membros.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "((a(b))c)+";
      string input = "abcabcabc";

      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: '{0}' at position {1}",
                           match.Value, match.Index);
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine("   Group {0}: '{1}' at position {2}",
                              ctr, groups[ctr].Value, groups[ctr].Index);
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine("      Capture {0}: '{1}' at position {2}",
                                 ctr2, captures[ctr2].Value, captures[ctr2].Index);
            }
         }
      }
   }
}
// The example displays the following output:
//       Match: 'abcabcabc' at position 0
//          Group 0: 'abcabcabc' at position 0
//             Capture 0: 'abcabcabc' at position 0
//          Group 1: 'abc' at position 6
//             Capture 0: 'abc' at position 0
//             Capture 1: 'abc' at position 3
//             Capture 2: 'abc' at position 6
//          Group 2: 'ab' at position 6
//             Capture 0: 'ab' at position 0
//             Capture 1: 'ab' at position 3
//             Capture 2: 'ab' at position 6
//          Group 3: 'b' at position 7
//             Capture 0: 'b' at position 1
//             Capture 1: 'b' at position 4
//             Capture 2: 'b' at position 7

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "((a(b))c)+"
        Dim input As STring = "abcabcabc"

        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Match: '{0}' at position {1}", _
                              match.Value, match.Index)
            Dim groups As GroupCollection = match.Groups
            For ctr As Integer = 0 To groups.Count - 1
                Console.WriteLine("   Group {0}: '{1}' at position {2}", _
                                  ctr, groups(ctr).Value, groups(ctr).Index)
                Dim captures As CaptureCollection = groups(ctr).Captures
                For ctr2 As Integer = 0 To captures.Count - 1
                    Console.WriteLine("      Capture {0}: '{1}' at position {2}", _
                                      ctr2, captures(ctr2).Value, captures(ctr2).Index)
                Next
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Match: 'abcabcabc' at position 0
'          Group 0: 'abcabcabc' at position 0
'             Capture 0: 'abcabcabc' at position 0
'          Group 1: 'abc' at position 6
'             Capture 0: 'abc' at position 0
'             Capture 1: 'abc' at position 3
'             Capture 2: 'abc' at position 6
'          Group 2: 'ab' at position 6
'             Capture 0: 'ab' at position 0
'             Capture 1: 'ab' at position 3
'             Capture 2: 'ab' at position 6
'          Group 3: 'b' at position 7
'             Capture 0: 'b' at position 1
'             Capture 1: 'b' at position 4
'             Capture 2: 'b' at position 7

O exemplo a seguir usa a expressão (Abc)+ regular para localizar uma ou mais execuções consecutivas da cadeia de caracteres "Abc" na cadeia de caracteres "XYZAbcAbcAbcXYZAbcAb". O exemplo ilustra o Group.Captures uso da propriedade para retornar vários grupos de substrings capturadas.

int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;

// Look for groupings of "Abc".
var r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;

// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());

// Loop through each group.
for (int i = 0; i < gc.Count; i++)
{
    cc = gc[i].Captures;
    counter = cc.Count;

    // Display the number of captures in this group.
    Console.WriteLine("Captures count = " + counter.ToString());

    // Loop through each capture in the group.
    for (int ii = 0; ii < counter; ii++)
    {
        // Display the capture and its position.
        Console.WriteLine(cc[ii] + "   Starts at character " +
             cc[ii].Index);
    }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9

Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection

' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups

' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())

' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
    cc = gc(i).Captures
    counter = cc.Count

    ' Display the number of captures in this group.
    Console.WriteLine("Captures count = " & counter.ToString())

    ' Loop through each capture in the group.            
    For ii = 0 To counter - 1
        ' Display the capture and its position.
        Console.WriteLine(cc(ii).ToString() _
            & "   Starts at character " & cc(ii).Index.ToString())
    Next ii
Next i
' The example displays the following output:
'       Captured groups = 2
'       Captures count = 1
'       AbcAbcAbc   Starts at character 3
'       Captures count = 3
'       Abc   Starts at character 3
'       Abc   Starts at character 6
'       Abc   Starts at character 9  

A Capture classe

A Capture classe contém os resultados de uma única captura de subexpressão. A Capture.Value propriedade contém o texto correspondente e indica Capture.Index a posição baseada em zero na cadeia de caracteres de entrada na qual a subcadeia de caracteres correspondente começa.

O exemplo a seguir analisa uma cadeia de caracteres de entrada para a temperatura de cidades selecionadas. Uma vírgula (",") é usada para separar uma cidade e sua temperatura, e um ponto-e-vírgula (";") é usado para separar os dados de cada cidade. A cadeia de caracteres de entrada inteira representa uma única correspondência. No padrão ((\w+(\s\w+)*),(\d+);)+de expressão regular , que é usado para analisar a cadeia de caracteres, o nome da cidade é atribuído ao segundo grupo de captura e a temperatura é atribuída ao quarto grupo de captura.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
      string pattern = @"((\w+(\s\w+)*),(\d+);)+";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Current temperatures:");
         for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
            Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
                              match.Groups[4].Captures[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Current temperatures:
//       Miami                 78
//       Chicago               62
//       New York              67
//       San Francisco         59
//       Seattle               58

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
        Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Current temperatures:")
            For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
                Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
                                  match.Groups(4).Captures(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Current temperatures:
'       Miami                 78
'       Chicago               62
'       New York              67
'       San Francisco         59
'       Seattle               58

A expressão regular é definida conforme mostrado na tabela a seguir.

Consulte também

• System.Text.RegularExpressions
• Expressões regulares do .NET
• Linguagem de Expressão Regular - Referência Rápida