Condividi tramite

Opzioni di espressioni regolari

  • Articolo

Per impostazione predefinita, il confronto di una stringa di input con qualsiasi carattere letterale in un criterio di espressione regolare prevede la distinzione tra maiuscole e minuscole, lo spazio vuoto in un criterio di espressione regolare viene interpretato come caratteri letterali di spazi vuoti e gruppi di acquisizione in un'espressione regolare sono denominati in modo implicito ed esplicito. È possibile modificare questi e molti altri aspetti del comportamento predefinito dell'espressione regolare specificando le opzioni dell'espressione regolare. Queste opzioni, elencate nella tabella seguente, possono essere incluse inline come parte del modello di espressione regolare o possono essere fornite a un costruttore della classe System.Text.RegularExpressions.Regex o a un metodo corrispondente al modello statico come valore di enumerazione System.Text.RegularExpressions.RegexOptions.

Membro RegexOptions

Carattere inline

Effetto

None

Non disponibile

Utilizzare il comportamento predefinito. Per ulteriori informazioni, vedere Opzioni predefinite.

IgnoreCase

i

Utilizzare la corrispondenza che non fa distinzione tra maiuscole e minuscole. Per ulteriori informazioni, vedere Corrispondenza senza distinzione tra maiuscole e minuscole.

Multiline

m

Utilizzare la modalità multiline, in cui ^ e $ corrispondono all'inizio e alla fine di ogni riga (anziché l'inizio e la fine della stringa di input). Per ulteriori informazioni, vedere Modalità multiriga.

Singleline

s

Utilizzare la modalità a riga singola, dove il punto (.) corrisponde a ogni carattere (anziché a ogni carattere ad eccezione di \n). Per ulteriori informazioni, vedere Modalità a riga singola.

ExplicitCapture

n

Non acquisire gruppi senza nome. Le uniche acquisizioni valide sono i gruppi denominati o numerati in modo esplicito nel formato (?<nome> sottoespressione). Per ulteriori informazioni, vedere Solo acquisizioni esplicite.

Compiled

Non disponibile

Compilare l'espressione regolare a un assembly. Per ulteriori informazioni vedere Espressioni regolari compilate.

IgnorePatternWhitespace

x

Escludere spazi vuoti non di escape dal modello e abilitare commenti dopo un simbolo cancelletto (#). Per ulteriori informazioni, vedere Ignora spazi.

RightToLeft

Non disponibile

Modificare la direzione di ricerca. La ricerca viene eseguita da destra verso sinistra, anziché da sinistra verso destra. Per ulteriori informazioni, vedere Modalità da destra a sinistra.

ECMAScript

Non disponibile

Consente un comportamento conforme a ECMAScript per l'espressione. Per ulteriori informazioni, vedere ECMAScript e comportamento di corrispondenza.

CultureInvariant

Non disponibile

Ignorare le differenze culturali della lingua. Per ulteriori informazioni, vedere Confronto utilizzando la lingua inglese.

Specifica delle opzioni

È possibile specificare le opzioni per le espressioni regolari in una delle tre modalità:

  • Nel parametro options di un costruttore di classe System.Text.RegularExpressions.Regex o di un metodo (Shared in Visual Basic) di corrispondenza dei modelli, come Regex.Regex(String, RegexOptions) or Regex.Match(String, String, RegexOptions). Il parametro options è una combinazione OR bit per bit dei valori enumerati da System.Text.RegularExpressions.RegexOptions.

    Nell'esempio seguente viene illustrato questo concetto. Utilizza il parametro options del metodo Regex.Match(String, String, RegexOptions) per abilitare la corrispondenza senza distinzione tra maiuscole e minuscole e ignorare gli spazi vuoti dei motivi durante l'identificazione di parole che iniziano con lettera "d".

    Dim pattern As String = "d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."
Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace

For Each match As Match In Regex.Matches(input, pattern, options)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

    string pattern = @"d \w+ \s";
string input = "Dogs are decidedly good pets.";
RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace;

foreach (Match match in Regex.Matches(input, pattern, options))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

  • Applicando opzioni inline in un criterio di espressione regolare con la sintassi (?imnsx-imnsx). L'opzione si applica al modello dal punto in cui viene definita l'opzione all'entità finale del modello o al punto in cui l'opzione non viene definita da un'altra opzione inline. Per ulteriori informazioni, vedere l'argomento Costrutti vari.

    Nell'esempio seguente viene illustrato questo concetto. Utilizza opzioni inline per abilitare la corrispondenza senza distinzione tra maiuscole e minuscole e ignorare gli spazi vuoti dei motivi durante l'identificazione di parole che iniziano con lettera "d".

    Dim pattern As String = "\b(?ix) d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

    string pattern = @"(?ix) d \w+ \s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

  • Applicando opzioni inline in un particolare costrutto di raggruppamento in un criterio di espressione regolare con la sintassi (?imnsx-imnsx: sottoespressione). Nessun segno prima di un set di opzioni attiva il set. Un segno meno prima di un set di opzioni disattiva il set. (? è una parte fissa della sintassi del costrutto di linguaggio richiesta se le opzioni sono abilitate o disabilitate.) L'opzione si applica solo a tale gruppo. Per ulteriori informazioni, vedere Costrutti di raggruppamento.

    Nell'esempio seguente viene illustrato questo concetto. Utilizza opzioni inline in un costrutto di raggruppamento per abilitare la corrispondenza senza distinzione tra maiuscole e minuscole e ignorare gli spazi vuoti dei motivi durante l'identificazione di parole che iniziano con lettera "d".

    Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

    string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Se si specificano opzioni inline, un segno meno (-) prima di un'opzione o di un set di opzioni disattiva tali opzioni. Ad esempio, il costrutto inline (?ix-ms) attiva le opzioni RegexOptions.IgnoreCase e RegexOptions.IgnorePatternWhitespace e disattiva le opzioni RegexOptions.Multiline e RegexOptions.Singleline. Per impostazione predefinita tutte le opzioni di espressioni regolari vengono disattivate.

NotaNota

Se le opzioni dell'espressione regolare specificate nel parametro options di un costruttore o di una chiamata al metodo sono in conflitto con le opzioni specificate inline in un criterio di espressione regolare, vengono utilizzate le opzioni inline.

Le cinque opzioni dell'espressione regolare, riportate di seguito, possono essere entrambe impostate con parametro e inline delle opzioni:

Le cinque opzioni dell'espressione regolare, riportate di seguito, possono essere impostate utilizzando il parametro options, anche se non è possibile impostare inline:

Determinazione di Opzioni

È possibile determinare quali opzioni sono state fornite a un oggetto Regex quando ne è stata creata l'istanza dal recupero del valore della proprietà Regex.Options di sola lettura. Tale proprietà è particolarmente utile per determinare le opzioni definite per un'espressione regolare compilata creata dal metodo Regex.CompileToAssembly.

Per verificare la presenza di qualsiasi opzione eccetto RegexOptions.None, eseguire un'operazione AND con il valore della proprietà Regex.Options e il valore RegexOptions desiderato. Verificare quindi se il risultato è uguale al valore RegexOptions. Nell'esempio seguente viene verificato se è stata impostata l'opzione RegexOptions.IgnoreCase.

If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
   Console.WriteLine("Case-insensitive pattern comparison.")
Else
   Console.WriteLine("Case-sensitive pattern comparison.")
End If   

if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
   Console.WriteLine("Case-insensitive pattern comparison.");
else
   Console.WriteLine("Case-sensitive pattern comparison.");

Per verificare RegexOptions.None, determinare se il valore della proprietà Regex.Options sia uguale a RegexOptions.None, come illustrato nell'esempio riportato di seguito.

If rgx.Options = RegexOptions.None Then
   Console.WriteLine("No options have been set.")
End If

if (rgx.Options == RegexOptions.None)
   Console.WriteLine("No options have been set.");

Nelle seguenti sezioni vengono elencate le opzioni supportate da espressioni regolari di .NET Framework.

Opzioni predefinite

L'opzione RegexOptions.None indica che non sono state specificate opzioni e il motore delle espressioni regolari utilizza il relativo comportamento predefinito. I miglioramenti includono quanto segue:

  • Il modello viene interpretato come un canonico piuttosto che come un'espressione regolare ECMAScript.

  • Il modello di espressione regolare corrisponde alla stringa di input da sinistra verso destra.

  • I confronti supportano la distinzione tra maiuscole e minuscole.

  • Gli elementi di linguaggio ^ e $ corrispondono all'inizio e alla fine della stringa di input.

  • L'elemento di linguaggio . corrisponde a ciascun carattere eccetto \n.

  • Qualsiasi spazio vuoto in un criterio di espressione regolare viene interpretato come uno spazio letterale.

  • Le convenzioni delle impostazioni cultura correnti vengono utilizzate in caso di confronto del modello con la stringa di input.

  • L'acquisizione di gruppi nel criterio di espressione regolare sono impliciti ed espliciti.

NotaNota

L'opzione RegexOptions.None non ha un equivalente inline.Quando le opzioni dell'espressione regolare sono applicate inline, il comportamento predefinito viene ripristinato su una base opzione per opzione, disattivando una particolare opzione.Ad esempio, (?i) attiva un confronto senza distinzione fra maiuscole e minuscole e (?-i) ripristina il confronto con distinzione tra maiuscole e minuscole predefinito.

Poiché l'opzione RegexOptions.None rappresenta il comportamento predefinito del motore delle espressioni regolari, raramente è specificato in modo esplicito in una chiamata al metodo. Viene invece chiamato un costruttore o un metodo statico dei criteri di ricerca senza un parametro options.

Torna all'inizio

Corrispondenza che non fa distinzione tra maiuscole e minuscole

L'opzione IgnoreCase o l'opzione inline i consente la corrispondenza senza distinzione tra maiuscole e minuscole. Per impostazione predefinita, vengono utilizzate le convenzioni sulla combinazione di maiuscole e minuscole delle impostazioni cultura correnti.

Nell'esempio riportato di seguito viene definito un modello di espressione regolare, \bthe\w*\b corrispondente a tutte le parole che iniziano con "the". Poiché la prima chiamata al metodo Match utilizza il confronto predefinito con distinzione tra maiuscole e minuscole, l'output indica che la stringa "Il" che inizia la frase non corrisponde. Viene confrontato quando il metodo Match viene chiamato con le opzioni impostate su IgnoreCase.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bthe\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, _
                                               RegexOptions.IgnoreCase)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bthe\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Nell'esempio seguente viene modificato il modello di espressione regolare dell'esempio precedente per utilizzare opzioni inline anziché il parametro options per fornire un confronto senza distinzione fra maiuscole e minuscole. Il primo modello definisce l'opzione di distinzione tra maiuscole e minuscole in un costrutto di raggruppamento che si applica solo alla lettera "t" nella stringa "the". Poiché si verifica il costrutto dell'opzione all'inizio del modello, il secondo modello applica l'opzione all'espressione regolare intera senza distinzione tra maiuscole e minuscole.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?i:t)he\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      pattern = "(?i)\bthe\w*\b"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?i:t)he\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      pattern = @"(?i)\bthe\w*\b";
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Torna all'inizio

Modalità multiriga

L'opzione RegexOptions.Multiline o l'opzione inline m consente di abilitare il motore delle espressioni regolari per gestire una stringa di input costituita da più righe. Modifica l'interpretazione degli elementi di lingua ^ e $ affinché corrispondano all'inizio e alla fine di una riga, anziché all'inizio e alla fine della stringa di input.

Per impostazione predefinita, $ corrisponde solo alla fine della stringa di input. Se si specifica l'opzione RegexOptions.Multiline, corrisponde al carattere di nuova riga (\n) o alla fine della stringa di input. Tuttavia, non corrisponde alla combinazione del carattere di ritorno a capo/avanzamento riga. Per farli corrispondere correttamente, utilizzare la sottoespressione \r?$ anziché solo $.

Nell'esempio seguente vengono estratti nomi e punteggi di giocatori di bocce e vengono aggiunti a una raccolta SortedList<TKey, TValue> che li ordina in ordine decrescente. Il metodo Matches viene chiamato due volte. Nella prima chiamata al metodo, l'espressione regolare è ^(\w+)\s(\d+)$ e nessuna opzione è impostata. Come mostra l'output, poiché il motore delle espressioni regolari non può corrispondere al modello di input all'inizio e alla fine della stringa di input, non viene trovata alcuna corrispondenza. Nella seconda chiamata al metodo, l'espressione regolare è modificata a ^(\w+)\s(\d+)\r?$ e le opzioni sono impostate su RegexOptions.Multiline. Come mostra l'output, i nomi e i punteggi sono corrisposti correttamente e i punteggi vengono visualizzati in ordine decrescente.

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

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())

      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "^(\w+)\s(\d+)$"
      Dim matched As Boolean = False

      Console.WriteLine("Without Multiline option:")
      For Each match As Match In Regex.Matches(input, pattern)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
         matched = True
      Next
      If Not matched Then Console.WriteLine("   No matches.")
      Console.WriteLine()

      ' Redefine pattern to handle multiple lines.
      pattern = "^(\w+)\s(\d+)\r*$"
      Console.WriteLine("With multiline option:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Without Multiline option:
'       No matches.
'    
'    With multiline option:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

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

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());

      string input = "Joe 164\n" + 
                     "Sam 208\n" + 
                     "Allison 211\n" + 
                     "Gwen 171\n"; 
      string pattern = @"^(\w+)\s(\d+)$";
      bool matched = false;

      Console.WriteLine("Without Multiline option:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);
         matched = true;
      }
      if (! matched)
         Console.WriteLine("   No matches.");
      Console.WriteLine();

      // Redefine pattern to handle multiple lines.
      pattern = @"^(\w+)\s(\d+)\r*$";
      Console.WriteLine("With multiline option:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y)
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//   Without Multiline option:
//      No matches.
//   
//   With multiline option:
//   Allison: 211
//   Sam: 208
//   Gwen: 171
//   Joe: 164

Il modello di espressione regolare ^(\w+)\s(\d+)\r*$ viene definito come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

^

Iniziare all'inizio della riga.

(\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.

\s

Trovare la corrispondenza di uno spazio vuoto.

(\d+)

Corrisponde a una o più cifre decimali. Equivale al secondo gruppo di acquisizione.

\r?

Trova la corrispondenza di zero o di carattere di ritorno a capo.

$

Termina alla fine della linea.

L'esempio riportato di seguito è uguale a quello precedente, tranne che per l'utilizzo dell'opzione inline (?m) per l'impostazione dell'opzione multiline.

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

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())

      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

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

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());

      string input = "Joe 164\n" +  
                     "Sam 208\n" +  
                     "Allison 211\n" +  
                     "Gwen 171\n"; 
      string pattern = @"(?m)^(\w+)\s(\d+)\r*$";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y) 
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//    Allison: 211
//    Sam: 208
//    Gwen: 171
//    Joe: 164

Torna all'inizio

Modalità a riga singola

L'opzione RegexOptions.Singleline o l'opzione inline s consente al motore delle espressioni regolari di gestire la stringa di input come se fosse costituita da una sola riga. A questo scopo modifica il comportamento dell'elemento di lingua del periodo (.) in modo che corrisponda a ogni carattere, anziché corrispondere a ogni carattere ad eccezione del carattere di nuova riga \n o \u000A.

Nell'esempio seguente viene illustrata come il comportamento dell'elemento di linguaggio . si modifica se si utilizza l'opzione RegexOptions.Singleline. L'espressione regolare ^.+ parte dall'inizio della stringa e individua una corrispondenza per ogni carattere. Per impostazione predefinita, la corrispondenza termina alla fine della prima riga; il criterio di espressione regolare corrisponde al carattere di ritorno a capo, \r o \u000D, ma non corrisponde a \n. Poiché l'opzione RegexOptions.Singleline interpreta la stringa di input intera come sola riga, ottiene una corrispondenza per ogni carattere nella stringa di input, incluso \n.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//       
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

L'esempio riportato di seguito è equivalente al precedente, tranne che per l'utilizzo dell'opzione inline (?s) per attivare la modalità a riga singola.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?s)^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {      
      string pattern = "(?s)^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Torna all'inizio

Solo acquisizioni esplicite

Per impostazione predefinita, i gruppi di acquisizione sono definiti dall'utilizzo di parentesi nel criterio di espressione regolare. Ai gruppi denominati viene assegnato un nome o un numero dall'opzione di linguaggio (?<nome >sottoespressione), mentre i gruppi senza nome sono accessibili mediante indice. Nell'oggetto GroupCollection, gruppi senza nome precedono gruppi denominati.

I costrutti di raggruppamento vengono spesso utilizzati solo per applicare quantificatori a più elementi di linguaggio e le sottostringhe acquisite non sono di alcun interesse. Ad esempio, se l'espressione regolare seguente:

\b\(?((\w+),?\s?)+[\.!?]\)?

si intende solo per l'estrazione di frasi che terminano con un punto, un punto esclamativo o un punto interrogativo da un documento, solo la frase risultante (che viene rappresentata dall'oggetto Match) presenta un interesse. L'insieme non contiene parole singole.

L'acquisizione di gruppi che non sono utilizzati successivamente può essere costosa, perché il motore delle espressioni regolari deve popolare sia gli oggetti Collection GroupCollection che CaptureCollection. Come alternativa, è possibile utilizzare l'opzione RegexOptions.ExplicitCapture o n inline per specificare che le sole acquisizioni valide sono gruppi denominati o numerati in modo esplicito, definiti dal costrutto (?< nome > sottoespressione).

Nell'esempio seguente vengono visualizzate informazioni sulle corrispondenze restituite dall'espressione regolare \b\(?((\w+),?\s?)+[\.!?]\)? quando il metodo Match viene chiamato con e senza l'opzione RegexOptions.ExplicitCapture. Come mostra l'output alla prima chiamata al metodo, il motore delle espressioni regolari popola interamente gli oggetti collection GroupCollection e CaptureCollection con le informazioni sulle sottostringhe acquisite. Poiché il secondo metodo viene chiamato con options impostato su RegexOptions.ExplicitCapture, non acquisisce informazioni sui gruppi.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
      Console.WriteLine("With implicit captures:")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
      Console.WriteLine()
      Console.WriteLine("With explicit captures only:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'    With implicit captures:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'       Group 1: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'       Group 2: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'       Group 1: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'       Group 2: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'       Group 1: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'       Group 2: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.
'       Group 1: paragraph
'          Capture 0: Instead,
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'       Group 2: paragraph
'          Capture 0: Instead
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'    
'    With explicit captures only:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
      Console.WriteLine("With implicit captures:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
      Console.WriteLine();
      Console.WriteLine("With explicit captures only:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//    With implicit captures:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//       Group 1: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//       Group 2: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//       Group 1: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//       Group 2: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//       Group 1: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//       Group 2: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
//       Group 1: paragraph
//          Capture 0: Instead,
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//       Group 2: paragraph
//          Capture 0: Instead
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//    
//    With explicit captures only:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.

Il modello di espressione regolare \b\(?((?>\w+),?\s?)+[\.!?]\)? viene definito come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Iniziare dal confine di una parola.

\(?

Ricerca la corrispondenza di zero o un'occorrenza della parentesi di apertura ("(").

(?>\w+),?

Trovare la corrispondenza di uno o più caratteri alfanumerici, seguiti da zero o una virgola. Non effettuare il backtracking durante l'associazione dei caratteri alfanumerici.

\s?

Ricerca la corrispondenza di zero o di uno spazio vuoto.

((\w+),? \s?)+

Ottiene una o più volte la corrispondenza con la combinazione di uno o più caratteri alfanumerici, zero o una virgola e zero o uno spazio vuoto.

[\.!?]\)?

Trova la corrispondenza di uno qualsiasi dei tre simboli di punteggiatura, seguiti da zero o da parentesi di chiusura (")").

È anche possibile utilizzare l'elemento inline (?n) per eliminare acquisizioni automatiche. Nell'esempio seguente viene modificato il modello di espressione regolare dell'esempio precedente per utilizzare l'elemento inline (?n) anziché l'opzione RegexOptions.ExplicitCapture.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Infine, è possibile utilizzare l'elemento di gruppo inline (?n:) per eliminare le acquisizioni automatiche gruppo per gruppo. Nell'esempio seguente viene modificato il modello precedente per eliminare acquisizioni senza nome nel gruppo esterno, ((?>\w+),?\s?). Notare che questo elimina anche acquisizioni senza nome nel gruppo interno.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Torna all'inizio

Espressioni regolari compilate

Per impostazione predefinita, vengono interpretate le espressioni regolari in .NET Framework. Quando viene creata l'istanza di un oggetto Regex o viene chiamato un metodo statico Regex, il modello di espressione regolare viene analizzato in un set di codici operativi personalizzati e un interprete utilizza tali codici operativi per eseguire l'espressione regolare. Comporta un compromesso: il costo dell'inizializzazione del motore delle espressioni regolari è ridotto alla spesa delle prestazioni in fase di esecuzione.

È possibile utilizzare espressioni regolari compilate anziché interpretate tramite l'opzione RegexOptions.Compiled. In questo caso, quando un modello viene passato al motore delle espressioni regolari, viene analizzato in un set di codici operativi, quindi viene convertito in Microsoft Intermediate Language (MSIL) di Microsoft che può essere passato direttamente al Common Language Runtime. Le espressioni regolari compilate ingrandiscono al massimo le prestazioni in fase di esecuzione a spese del tempo di inizializzazione.

NotaNota

Un'espressione regolare può essere compilata solo fornendo il valore RegexOptions.Compiled al parametro options di un costruttore di classe Regex o un metodo statico del criterio di ricerca.Non è disponibile come opzione inline.

È possibile utilizzare espressioni regolari compilate nelle chiamate a entrambe le espressioni regolari statiche e di istanza. Nelle espressioni regolari statiche, l'opzione RegexOptions.Compiled viene passata al parametro options del metodo di corrispondenza dei modelli dell'espressione regolare. Nelle espressioni regolari dell'istanza, viene passato al parametro options del costruttore della classe Regex. In entrambi casi, comporta prestazioni migliorate.

Questo miglioramento nelle prestazioni, tuttavia, si verifica solo in presenza delle condizioni seguenti:

  • Un oggetto Regex che rappresenta un'espressione regolare statica è utilizzato in più chiamate a metodi operanti in base a criteri di ricerca di espressioni regolari.

  • L'oggetto Regex non può uscire dall'ambito, quindi può essere riutilizzato.

  • Un'espressione regolare statica è utilizzata in più chiamate a metodi operanti in base a criteri di ricerca di espressioni regolari. (Il miglioramento nelle prestazioni è possibile perché espressioni regolari utilizzate nelle chiamate ai metodi statici vengono memorizzate nella cache dal motore delle espressioni regolari.)

NotaNota

L'opzione RegexOptions.Compiled non è correlata al metodo Regex.CompileToAssembly che crea un assembly a scopi specifici contenente espressioni regolari compilate predefinite.

Torna all'inizio

Ignora spazi vuoti

Per impostazione predefinita, lo spazio vuoto in un criterio di espressione regolare è significativo; forza il motore delle espressioni regolari a trovare la corrispondenza di uno spazio vuoto nella stringa di input. Di conseguenza, l'espressione regolare "\b\w+\s" e "\b\w+ " equivalgono quasi a espressioni regolari equivalenti. Inoltre, quando si incontra il simbolo cancelletto (#) nei criteri di espressioni regolari, viene interpretato come un carattere letterale di cui trovare una corrispondenza.

L'opzione RegexOptions.IgnorePatternWhitespace o l'opzione inline x modifica tale comportamento predefinito come segue:

  • Vengono ignorati gli spazi vuoti non di escape nel modello di espressione regolare. Per far parte di un modello di espressione regolare, i caratteri spazio vuoto devono essere di tipo escape (ad esempio, come \s o "\ ").

    Nota importanteImportante

    Lo spazio vuoto all'interno di una classe di caratteri viene interpretato letteralmente a prescindere dall'utilizzo dell'opzione RegexOptions.IgnorePatternWhitespace.Ad esempio, il criterio di espressione regolare [ .,;:] corrisponde a qualsiasi spazio vuoto, punto, virgola, punto e virgola o due punti.

  • Il simbolo cancelletto (#) viene interpretato come inizio di un commento, piuttosto che come un carattere letterale. Ogni testo nel criterio di espressione regolare dal carattere # alla fine della stringa viene interpretato come un commento.

L'abilitazione di questa opzione consente di semplificare espressioni regolari che sono spesso difficili da analizzare e capire. Migliora la leggibilità e rende possibile documentare un'espressione regolare.

L'esempio seguente definisce il modello di espressione regolare seguente:

\b \(? ( (?>\w+) ,? \s? )+ [\.!?] \)? # Matches an entire sentence.

Tale modello è simile a quello definito nella sezione Solo acquisizioni esplicite, eccetto nel caso utilizzi l'opzione RegexOptions.IgnorePatternWhitespace per ignorare lo spazio vuoto del modello.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Nell'esempio seguente viene utilizzata l'opzione inline (?x) per ignorare lo spazio vuoto del modello.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Torna all'inizio

Modalità da destra a sinistra

Per impostazione predefinita, il motore di espressione regolare effettua la ricerca da destra a sinistra. È possibile invertire la direzione della ricerca tramite l'opzione RegexOptions.RightToLeft. La ricerca inizia automaticamente nell'ultima posizione dei caratteri della stringa. Per metodi del criterio di ricerca che includono un parametro della posizione iniziale, come ad esempio Regex.Match(String, Int32), la posizione iniziale è l'indice della posizione dell'ultimo carattere a destra al quale ha inizio la ricerca.

NotaNota

È disponibile la modalità del modello da destra a sinistra solo fornendo il valore RegexOptions.RightToLeft sul parametro options di un costruttore della classe Regex o del metodo di corrispondenza dei modelli statico.Non è disponibile come opzione inline.

L'opzione RegexOptions.RightToLeft modifica solo la direzione di ricerca; non interpreta il modello di espressione regolare da destra a sinistra. Ad esempio, le corrispondenze \bb\w+\s dell'espressione regolare sono relative a parole che iniziano con la lettera "b" e sono seguite da uno spazio vuoto. Nell'esempio seguente, la stringa di input è costituita da tre parole che comprendono uno o più caratteri "b." La prima parola inizia con "b", la seconda termina con "b" e la terza comprende due caratteri "b" al centro della parola. Come mostra l'output dall'esempio, solo le prime parole corrispondono al criterio di espressione regolare.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bb\w+\s"
      Dim input As String = "builder rob rabble"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)     
      Next
   End Sub
End Module
' The example displays the following output:
'       'builder ' found at position 0.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bb\w+\s";
      string input = "builder rob rabble";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);     
   }
}
// The example displays the following output:
//       'builder ' found at position 0.

Notare inoltre che l'asserzione di lookahead (la (?=sottoespressione) elemento di linguaggio) e l'asserzione lookbehind (la (?<=sottoespressione) elemento di linguaggio) non cambia direzione. Le asserzioni lookahead appaiono a destra; le asserzioni lookbehind a sinistra. Ad esempio, l'espressione regolare (?<=\d{1,2}\s)\w+,*\s\d{4} utilizza l'asserzione lookbehind per verificare una data che precede un nome del mese. L'espressione regolare corrisponde quindi al mese e all'anno. Per informazioni su lookahead e asserzioni lookbehind, vedere Costrutti di raggruppamento.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "1 May 1917", "June 16, 2003" }
      Dim pattern As String = "(?<=\d{1,2}\s)\w+,?\s\d{4}"

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
         If match.Success Then
            Console.WriteLine("The date occurs in {0}.", match.Value)
         Else
            Console.WriteLine("{0} does not match.", input)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       The date occurs in May 1917.
'       June 16, 2003 does not match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "1 May 1917", "June 16, 2003" };
      string pattern = @"(?<=\d{1,2}\s)\w+,?\s\d{4}";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
         if (match.Success)
            Console.WriteLine("The date occurs in {0}.", match.Value);
         else
            Console.WriteLine("{0} does not match.", input);
      }
   }
}
// The example displays the following output:
//       The date occurs in May 1917.
//       June 16, 2003 does not match.

Il modello di espressione regolare viene definito come illustrato nella tabella riportata di seguito.

Modello

Oggetto di descrizione

(?<=\d{1,2}\s)

L'inizio della corrispondenza deve essere preceduto da uno o due cifre decimali seguite da uno spazio.

\w+

Trovare la corrispondenza di uno o più caratteri alfanumerici.

,*

Trova la corrispondenza di zero o di carattere virgola.

\s

Trovare la corrispondenza di uno spazio vuoto.

\d{4}

Corrisponde a quattro cifre decimali.

Torna all'inizio

Funzione delle corrispondenze ECMAScript

Per impostazione predefinita, il motore di espressione regolare utilizza un comportamento canonico nella ricerca di corrispondenza di un modello di espressione regolare nel testo di input. Tuttavia, è possibile istruire il motore delle espressioni regolari in modo che utilizzi il comportamento di corrispondenza ECMAScript specificando l'opzione RegexOptions.ECMAScript.

NotaNota

Un comportamento conforme a ECMAScript è disponibile solo fornendo il valore RegexOptions.ECMAScript sul parametro options di un costruttore della classe Regex o del metodo di corrispondenza dei modelli statico.Non è disponibile come opzione inline.

L'opzione RegexOptions.ECMAScript può essere combinata solo con le opzioni RegexOptions.IgnoreCase e RegexOptions.Multiline. L'utilizzo di qualsiasi altra opzione in un'espressione regolare provoca un ArgumentOutOfRangeException.

Il comportamento di ECMAScript e le espressioni regolari canoniche differiscono in tre aree: sintassi delle classi di caratteri, gruppi di acquisizione autoreferenziali e interpretazione ottale rispetto a backreference.

  • Sintassi delle classi di caratteri. Poiché le espressioni regolari canoniche supportano Unicode a differenza di ECMAScript, classi di caratteri in ECMAScript hanno una sintassi più limitata e alcuni elementi di linguaggio della classe di caratteri hanno un significato diverso. Ad esempio, ECMAScript non supporta elementi di linguaggio quali la categoria Unicode o elementi del blocco \p e \P. Allo stesso modo, l'elemento \w corrispondente a un carattere alfanumerico è equivalente alla classe di caratteri [a-zA-Z_0-9] in caso di utilizzo di ECMAScript e [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] quando si utilizza un comportamento canonico. Per ulteriori informazioni, vedere Classi di caratteri.

    Nell'esempio seguente viene illustrata la differenza fra la corrispondenza dei modelli canonici e quelli ECMAScript. Definisce un'espressione regolare, \b(\w+\s*)+, che corrisponde a parole seguite da spazi bianchi. L'input è costituito da due stringhe, una che utilizza il set di caratteri latini e l'altra che utilizza il set di caratteri cirillici. Come mostra l'output, la chiamata al metodo Regex.IsMatch(String, String, RegexOptions) che utilizza la corrispondenza ECMAScript non riesce a trovare la corrispondenza con le parole in cirilliche, mentre la chiamata al metodo che utilizza corrispondenza canonica corrisponde a queste parole.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim values() As String = { "целый мир", "the whole world" }
      Dim pattern As String = "\b(\w+\s*)+"
      For Each value In values
         Console.Write("Canonical matching: ")
         If Regex.IsMatch(value, pattern)
            Console.WriteLine("'{0}' matches the pattern.", value)
         Else
            Console.WriteLine("{0} does not match the pattern.", value)
         End If

         Console.Write("ECMAScript matching: ")
         If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)
            Console.WriteLine("'{0}' matches the pattern.", value)
         Else
            Console.WriteLine("{0} does not match the pattern.", value)
         End If
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       Canonical matching: 'целый мир' matches the pattern.
'       ECMAScript matching: целый мир does not match the pattern.
'       
'       Canonical matching: 'the whole world' matches the pattern.
'       ECMAScript matching: 'the whole world' matches the pattern.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "целый мир", "the whole world" };
      string pattern = @"\b(\w+\s*)+";
      foreach (var value in values)
      {
         Console.Write("Canonical matching: ");
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("'{0}' matches the pattern.", value);
         else
            Console.WriteLine("{0} does not match the pattern.", value);

         Console.Write("ECMAScript matching: ");
         if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
            Console.WriteLine("'{0}' matches the pattern.", value);
         else
            Console.WriteLine("{0} does not match the pattern.", value);
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Canonical matching: 'целый мир' matches the pattern.
//       ECMAScript matching: целый мир does not match the pattern.
//       
//       Canonical matching: 'the whole world' matches the pattern.
//       ECMAScript matching: 'the whole world' matches the pattern.

  • Gruppi di acquisizione autoreferenziali. È necessario aggiornare una classe di acquisizione di espressioni regolari con un backreference riferito a sé stessa ogni volta che eseguita un'iterazione dell'acquisizione. Come mostra l'esempio seguente, questa funzionalità consente all'espressione regolare ((a+)(\1) ?)+ di corrispondere alla stringa di input " aa aaaa aaaaaa " in caso di utilizzo di ECMAScript, ma non in caso di utilizzo di corrispondenza canonica.

    L'espressione regolare viene definita come illustrato nella tabella seguente.

    Modello

    Oggetto di descrizione

    (a+)

    Trova la corrispondenza della lettera "a" una o più volte. Equivale al secondo gruppo di acquisizione.

    (\1)

    Trova la corrispondenza della sottostringa acquisita dal primo gruppo di acquisizione. Equivale al terzo gruppo di acquisizione.

    ?

    Ricerca la corrispondenza di zero o di uno spazio.

    ((a+)(\1) ?)+

    Ottiene una o più volte la corrispondenza di caratteri "a" seguiti da una stringa che corrisponde al primo gruppo di acquisizione seguito da zero o da uno spazio vuoto, una o più volte. Equivale al primo gruppo di acquisizione.

  • Risoluzione delle ambiguità tra caratteri di escape ottali e backreference. Nella tabella riportata di seguito vengono indicate le differenze tra l'interpretazione ottale e quella dei backreference nelle espressioni regolari canoniche e di ECMAScript

    Espressione regolare

    Comportamento canonico

    Comportamento di ECMAScript

    \0 seguito da cifre ottali comprese tra 0 e 2

    Interpretare come un ottale. Ad esempio, \044 viene sempre interpretato come un valore ottale e significa "$."

    Stesso comportamento.

    \ seguito da una cifra compresa tra 1 e 9, quindi da nessuna cifra decimale aggiuntiva

    Interpretare come un backreference. Ad esempio, \9 rappresenta sempre un backreference 9, anche se il nono gruppo di acquisizione non esiste. Se il gruppo di acquisizione non esiste, il parser dell'espressione regolare genera ArgumentException.

    Se esiste un gruppo di acquisizione di una singola cifra decimale, il carattere viene considerato un backreference di tale cifra. Altrimenti il valore viene interpretato come un valore letterale.

    \ seguito da una cifra compresa tra 1 e 9, quindi da ulteriori cifre decimali

    Interpretare le cifre come un valore decimale. Se tale gruppo di acquisizione esiste, l'espressione viene interpretata come un backreference.

    In caso contrario, interpretare le cifre ottali iniziali fino all'ottale 377, ovvero considerare solo gli 8 bit inferiori del valore. Interpretare le cifre restanti come valori letterali. Ad esempio, nell'espressione \3000, se il gruppo di acquisizione 300 esiste, l'espressione viene interpretata come un backreference 300; se il gruppo di acquisizione 300 non esiste, viene interpretata come ottale 300 seguito da 0.

    Interpretare come un backreference convertendo il maggior numero possibile di cifre a un valore decimale che si può riferire a un'acquisizione. Se non è possibile convertire alcuna cifra, interpretare il carattere come un ottale utilizzando le cifre ottali iniziali fino all'ottale 377. Interpretare le cifre restanti come valori letterali.

Torna all'inizio

Confronto utilizzando la lingua inglese

Per impostazione predefinita, quando il motore delle espressioni regolari esegue confronti senza distinzione fra maiuscole e minuscole, utilizza le convenzioni sulla combinazione di maiuscole e minuscole delle impostazioni cultura correnti per determinare caratteri maiuscoli e minuscoli equivalenti.

Tuttavia, questo comportamento risulta inappropriato per alcuni tipi di confronti, in particolare nel caso di confronto di input dell'utente con i nomi di risorse di sistema, ad esempio password, file o URL. Nell'esempio riportato di seguito viene illustrato tale scenario. Il codice ha lo scopo di bloccare l'accesso a qualsiasi risorsa il cui URL è preceduto da FILE://. L'espressione regolare tenta una corrispondenza senza distinzione tra maiuscole e minuscole con la stringa tramite l'espressione regolare $FILE://. Tuttavia, quando le impostazioni cultura del sistema correnti sono tr-TR (turco di Turchia), "I" non è l'equivalente maiuscolo di "i." Di conseguenza, la chiamata al metodo Regex.IsMatch restituisce false e l'accesso al file è consentito.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-sensitive matching ({0} culture)...", _
                  Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If

Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'       Culture-sensitive matching (tr-TR culture)...
'       Access to file://c:/Documents.MyReport.doc is allowed.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-sensitive matching ({0} culture)...", 
                  Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("URLs that access files are not allowed.");      
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-sensitive matching (tr-TR culture)...
//       Access to file://c:/Documents.MyReport.doc is allowed.
NotaNota

   Per ulteriori informazioni sui confronti di stringhe che supportano la distinzione tra maiuscole e minuscole e che utilizzano la lingua inglese, vedere Procedure consigliate per l'utilizzo di stringhe in .NET Framework.

Anziché utilizzare i confronti senza distinzione fra maiuscole e minuscole delle impostazioni cultura correnti, è possibile specificare l'opzione RegexOptions.CultureInvariant per ignorare le differenze culturali di lingua e utilizzare le convenzioni della lingua inglese.

NotaNota

Il confronto utilizzando la lingua inglese è disponibile solo fornendo il valore RegexOptions.CultureInvariant al parametro options di un costruttore della classe Regex o del metodo di corrispondenza dei modelli statico.Non è disponibile come opzione inline.

L'esempio riportato di seguito è identico al precedente, tranne che per il metodo statico Regex.IsMatch(String, String, RegexOptions) chiamato con opzioni che includono RegexOptions.CultureInvariant. Anche quando le impostazioni cultura correnti sono quelle del turco (Turchia), il motore delle espressioni regolari consente di individuare la corrispondenza tra "FILE" e "file" e di bloccare l'accesso alla risorsa del file.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern, _
               RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'        Culture-insensitive matching...
'        URLs that access files are not allowed.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern, 
                  RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)) 
   Console.WriteLine("URLs that access files are not allowed.");
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-insensitive matching...
//       URLs that access files are not allowed.

Torna all'inizio

Vedere anche

Concetti

Elementi del linguaggio di espressioni regolari