Construtores Diversos

Expressões regulares na.NET Framework inclui três construções de linguagem de diversos. Uma permite habilitar ou desabilitar opções de correspondência de determinado no meio de um padrão de expressão regular. Os dois restantes permitem incluir comentários em uma expressão regular.

Opções de linha

Você pode definir ou desabilitar um padrão específico de opções para a parte de uma expressão regular de correspondência, usando a sintaxe

(?imnsx-imnsx)

Você listar as opções que você deseja habilitar após o ponto de interrogação e as opções que você deseja desativar após o sinal de subtração. A tabela a seguir descreve cada opção. Para obter mais informações sobre cada opção, consulte Opções de expressão Regular.

Opção	Descrição
i	Correspondência de maiúsculas e minúsculas.
m	Modo de várias linhas.
n	Apenas capturas explícitas. (Entre parênteses não agem como captura de grupos.)
s	Modo de linha única.
x	Ignorar espaços em branco sem escape e permitir comentários do modo x.

Qualquer alteração nas opções de expressão regular, definida pela (?imnsx-imnsx) construção permanece em vigor até o fim do grupo delimitador.

Observação

O (?imnsx-imnsx:subexpressão) a construção de agrupamento fornece funcionalidades idênticas para uma subexpressão.Para obter mais informações, consulte Agrupando Construtores.

O exemplo a seguir usa a i, n, e x Opções para habilitar a não diferenciação de maiúsculas e minúsculas e capturas explícitas e para ignorar espaços em branco no padrão de expressão regular no meio de uma expressão regular.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String 
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

      pattern = "\b(D\w+)\s(d\w+)\b"
      ' Match pattern using default options.
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
      Console.WriteLine()

      ' Change regular expression pattern to include options.
      pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
      ' Match new pattern with options. 
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern; 
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
      }
      Console.WriteLine();

      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options. 
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//       
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'

O exemplo define duas expressões regulares. A primeira, \b(D\w+)\s(d\w+)\b, que corresponde a duas palavras consecutivas que começam com um "D" maiúsculo e uma "d" de minúsculas. A segunda expressão regular, \b(D\w+)(?ixn) \s (d\w+) \b, usa as opções de linha para modificar esse padrão, conforme descrito na tabela a seguir. Uma comparação dos resultados confirma o efeito de (?ixn) construção.

Padrão	Descrição
\b	Iniciar em um limite de palavra.
(D\w+)	Corresponde ao "D" maiúsculo seguido por um ou mais caracteres do word. Este é o primeiro grupo de captura.
(?ixn)	A partir deste ponto em fazer comparações de maiúsculas e minúsculas, tornar explícito só captura e ignorar o espaço em branco no padrão de expressão regular.
\s	Corresponde a um caractere de espaço em branco.
(d\w+)	Corresponde a um maiúscula ou minúscula "d" seguido por um ou mais caracteres do word. Esse grupo não for capturado, porque o n (captura explícita) opção foi ativada...
\b	Corresponde a um limite de palavra.

Comentário de linha

O (?# comentário) construção permite que você incluir um comentário in-line em uma expressão regular. O mecanismo de expressão regular não usar qualquer parte do comentário na correspondência de padrões, embora o comentário é incluído na seqüência de caracteres é retornada pelo Regex.ToString método. O comentário termina com o parêntese de fechamento primeiro.

O exemplo a seguir repete o primeiro padrão de expressão regular do exemplo na seção anterior. Ele adiciona dois comentários de in-line para a expressão regular para indicar se a comparação é diferencia maiúsculas de minúsculas. O padrão de expressão regular, \b((?# case-sensitive comparison)D\w+)\s((?#case-insensitive comparison)d\w+)\b, que é definido como segue:

Padrão	Descrição
\b	Iniciar em um limite de palavra.
(?# case-sensitive comparison)	Um comentário. Ele não afeta o comportamento de correspondência de padrões.
(D\w+)	Corresponde ao "D" maiúsculo seguido por um ou mais caracteres do word. Este é o primeiro grupo de capturando.
\s	Corresponde a um caractere de espaço em branco.
(?ixn)	A partir deste ponto em fazer comparações de maiúsculas e minúsculas, tornar explícito só captura e ignorar o espaço em branco no padrão de expressão regular.
(?#case-insensitive comparison)	Um comentário. Ele não afeta o comportamento de correspondência de padrões.
(d\w+)	Corresponde a um maiúscula ou minúscula "d" seguido por um ou mais caracteres do word. Este é o segundo grupo de captura.
\b	Corresponde a um limite de palavra.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comparison)d\w+)\b"
      Dim rgx As New Regex(pattern)
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

      Console.WriteLine("Pattern: " + pattern.ToString())
      ' Match pattern using default options.
      For Each match As Match In rgx.Matches(input)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            for (int ctr = 1; ctr <match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         }
      }
   }
}
// The example displays the following output:
//    Pattern: \b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded

Fim de linha de comentário

Um sinal numérico (#) marca um comentário de modo x, que começa com o caractere de escape # no final do padrão de expressão regular e continua até o final da linha. Para usar essa construção, você deve ativar o x opção (por meio de opções de linha) ou fornecer o RegexOptions.IgnorePatternWhitespace valor para o option parâmetro ao instanciar o Regex objeto ou chamar um estático Regex método.

O exemplo a seguir ilustra a construção de fim de linha de comentário. Ele determina se uma seqüência de caracteres é uma seqüência de caracteres de formato composto que inclua pelo menos um item de formato. A tabela a seguir descreve as construções no padrão de expressão regular:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

Padrão	Descrição
\{	Corresponde a uma chave de abertura.
\d+	Corresponde a um ou mais dígitos decimais.
(,-*\d+)*	Corresponde a zero ou uma de ocorrência de uma vírgula, seguida por um sinal de subtração opcional, seguido por um ou mais dígitos decimais.
(\:\w{1,4}?)*	Corresponde à ocorrência de zero ou um de dois-pontos, seguido de um a quatro, mas como alguns caracteres de possíveis, o espaço em branco.
(?#case insensitive comparison)	Um comentário in-line. Ele não tem efeito sobre a correspondência de padrões de comportamento.
\}	Corresponde a uma chave de fechamento.
(?x)	Ative a opção de espaço em branco de padrão de ignorar, para que o comentário de final de linha será reconhecido.
# Looks for a composite format item.	Um comentário de final de linha.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
      Dim input As String = "{0,-3:F}"
      Console.WriteLine("'{0}':", input)
      If Regex.IsMatch(input, pattern) Then
         Console.WriteLine("   contains a composite format item.")
      Else
         Console.WriteLine("   does not contain a composite format item.")
      End If
   End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine("'{0}':", input);
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.

Observe que, em vez de fornecer o (?x) Construir na expressão regular, o comentário foi também foram reconhecido chamando o Regex.IsMatch(String, String, RegexOptions) método e passando-o RegexOptions.IgnorePatternWhitespace valor de enumeração.

Consulte também

Conceitos

Elementos de linguagem das expressões regulares