Costrutti vari

Le espressioni regolari in .NET Framework includono tre costrutti di linguaggio misti. Consente di abilitare o disabilitare opzioni di corrispondenza specifiche all'interno di un modello di espressione regolare. I due restanti consentono di includere commenti in un'espressione regolare.

Opzioni Inline

È possibile impostare o disabilitare opzioni del criterio di ricerca specifiche per parte di un'espressione regolare tramite la sintassi

(?imnsx-imnsx)

Si elencano le opzioni che si desidera attivare dopo il punto interrogativo e le opzioni che si desidera disabilitare dopo il segno di sottrazione. Nella seguente tabella viene descritta ciascuna opzione. Per ulteriori informazioni su ogni opzione, vedere Opzioni di espressioni regolari.

Opzione	Oggetto di descrizione
i	Corrispondenza che non fa distinzione tra maiuscole e minuscole.
m	Modalità multiriga.
n	Solo acquisizioni esplicite. (Le parentesi non funzionano come gruppi di acquisizione.)
s	Modalità a riga singola.
x	Ignora spazi vuoti non validi e consenti i commenti in modalità X.

Qualsiasi modifica nelle opzioni dell'espressione regolare definita dal costrutto (?imnsx-imnsx) rimane attiva fino alla fine del gruppo di inclusione.

Nota
Il costrutto di raggruppamento (?imnsx-imnsx:subexpression) fornisce la funzionalità identica per una sottoespressione.Per ulteriori informazioni, vedere Costrutti di raggruppamento.

Nell'esempio seguente vengono utilizzate le opzioni i, n e x per attivare la mancata distinzione tra maiuscole e minuscole e le acquisizioni esplicite, e per ignorare lo spazio vuoto nel criterio dell'espressione regolare all'interno di un'espressione regolare.

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'

Nell'esempio vengono definite due espressioni regolari. Il primo, \b(D\w+)\s(d\w+)\b, corrisponde a due parole consecutive che iniziano con una "D" maiuscola e una "d" minuscola. La seconda espressione regolare, \b(D\w+)(?ixn) \s (d\w+) \b, utilizza opzioni inline per modificare questo modello, come descritto nella tabella seguente. Un confronto dei risultati conferma l'effetto del costrutto (?ixn).

Modello	Oggetto di descrizione
\b	Iniziare dal confine di una parola.
(D\w+)	Corrisponde a una "D" maiuscola seguita da uno o più caratteri alfanumerici. Si tratta del primo gruppo di acquisizione.
(?ixn)	Da questo punto in avanti, effettuare confronti senza distinzione tra maiuscole e minuscole, fare solo acquisizioni esplicite e ignorare gli spazi vuoti nel criterio di espressione regolare.
\s	Trovare la corrispondenza di uno spazio vuoto.
(d\w+)	Corrisponde a una "d" maiuscola o minuscola seguita da uno o più caratteri alfanumerici. Questo gruppo non viene acquisito perché è stata attivata l'opzione n (acquisizione esplicita).
\b	Trovare la corrispondenza di un confine di parola.

Commento Inline

Il costrutto (?# comment) consente di includere un commento inline in un'espressione regolare. Il motore delle espressioni regolari non utilizza parti del commento nella corrispondenza tra modelli, anche se il commento è incluso nella stringa restituita dal metodo Regex.ToString. Il commento termina in corrispondenza della prima parentesi chiusa.

Nell'esempio riportato di seguito viene ripetuto il primo modello di espressione regolare dell'esempio fornito nella sezione precedente. Aggiunge due commenti inline all'espressione regolare per indicare se il confronto prevede la distinzione tra maiuscole e minuscole. Il modello dell'espressione regolare, \b((?# case-sensitive comparison)D\w+)\s((?#case-insensitive comparison)d\w+)\b, viene definito nel seguente modo.

Modello	Oggetto di descrizione
\b	Iniziare dal confine di una parola.
(?# case-sensitive comparison)	Commento. Non influisce sul comportamento dei criteri di ricerca.
(D\w+)	Corrisponde a una "D" maiuscola seguita da uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.
\s	Trovare la corrispondenza di uno spazio vuoto.
(?ixn)	Da questo punto in avanti, effettuare confronti senza distinzione tra maiuscole e minuscole, fare solo acquisizioni esplicite e ignorare gli spazi vuoti nel criterio di espressione regolare.
(?#case-insensitive comparison)	Commento. Non influisce sul comportamento dei criteri di ricerca.
(d\w+)	Corrisponde a una "d" maiuscola o minuscola seguita da uno o più caratteri alfanumerici. Si tratta del secondo gruppo di acquisizione.
\b	Trovare la corrispondenza di un confine di parola.

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

Commento a fine riga

Un simbolo di cancelletto (#) contrassegna un commento in modalità x che inizia dal valore senza caratteri escape # alla fine del criterio di espressione regolare e continua fino alla fine della riga. Per utilizzare questo costrutto, è necessario attivare l'opzione x (tramite opzioni inline) o fornire il valore RegexOptions.IgnorePatternWhitespace al parametro option in caso di creazione di un'istanza dell'oggetto Regex o di chiamata a un metodo statico di Regex.

Nell'esempio seguente viene illustrato il costrutto del commento di fine riga. Determina se una stringa è una stringa di formato composto che include almeno un elemento di formato. Nella tabella riportata di seguito vengono descritti i costrutti nel modello dell'espressione regolare:

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

Modello	Oggetto di descrizione
\{	Corrisponde a una parentesi graffa aperta.
\d+	Corrisponde a una o più cifre decimali.
(,-*\d+)*	Corrisponde a zero o a un'occorrenza di una virgola, seguita da un segno di sottrazione facoltativo, seguito da una o più cifre decimali.
(\:\w{1,4}?)*	Corrisponde a zero o a un'occorrenza del segno dei due punti, seguito da 1-4 spazi vuoti (ma comunque il minor numero di caratteri possibile).
(?#case insensitive comparison)	Commento inline. Non ha alcun effetto sul comportamento dei criteri di ricerca.
\}	Corrisponde a una parentesi graffa di chiusura.
(?x)	Attiva l'opzione per ignorare gli spazi vuoti nei motivi per riconoscere il commento a fine riga.
# Looks for a composite format item.	Un commento a fine riga.

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.

Anziché fornire il costrutto (?x) nell'espressione regolare, sarebbe stato possibile riconoscere il commento chiamando il metodo Regex.IsMatch(String, String, RegexOptions) e passandogli il valore di enumerazione RegexOptions.IgnorePatternWhitespace.

Vedere anche

Concetti

Elementi del linguaggio di espressioni regolari