Modello a oggetti delle espressioni regolariThe Regular Expression Object Model

In questo argomento viene illustrato il modello a oggetti usato con le espressioni regolari di .NET.This topic describes the object model used in working with .NET regular expressions. Include le sezioni seguenti:It contains the following sections:

Motore delle espressioni regolariThe Regular Expression Engine

Il motore delle espressioni regolari di .NET è rappresentato dalla classe Regex.The regular expression engine in .NET is represented by the Regex class. Il motore delle espressioni regolari è responsabile dell'analisi e della compilazione di un'espressione regolare e dell'esecuzione di operazioni che associano il criterio di espressione regolare a una stringa di input.The regular expression engine is responsible for parsing and compiling a regular expression, and for performing operations that match the regular expression pattern with an input string. Il motore è il componente centrale del modello a oggetti delle espressioni regolari di .NET.The engine is the central component in the .NET regular expression object model.

È possibile usare il motore delle espressioni regolari in uno dei due modi seguenti:You can use the regular expression engine in either of two ways:

  • Tramite la chiamata di metodi statici della classe Regex.By calling the static methods of the Regex class. I parametri del metodo includono la stringa di input e il criterio di espressione regolare.The method parameters include the input string and the regular expression pattern. Il motore delle espressioni regolari memorizza nella cache le espressioni regolari usate nelle chiamate del metodo statico. Le chiamate ripetute a metodi di espressione regolare che usano la stessa espressione regolare offrono quindi prestazioni relativamente buone.The regular expression engine caches regular expressions that are used in static method calls, so repeated calls to static regular expression methods that use the same regular expression offer relatively good performance.

  • Tramite la creazione di istanze di un oggetto Regex, mediante il passaggio di un'espressione regolare al costruttore di classe.By instantiating a Regex object, by passing a regular expression to the class constructor. In questo caso l'oggetto Regex è non modificabile (sola lettura) e rappresenta un motore delle espressioni regolari strettamente associato a una singola espressione regolare.In this case, the Regex object is immutable (read-only) and represents a regular expression engine that is tightly coupled with a single regular expression. Poiché le espressioni regolari usate dalle istanze di Regex non sono memorizzate nella cache, è consigliabile non creare più volte istanze di un oggetto Regex con la stessa espressione regolare.Because regular expressions used by Regex instances are not cached, you should not instantiate a Regex object multiple times with the same regular expression.

È possibile chiamare i metodi della classe Regex per eseguire le operazioni seguenti:You can call the methods of the Regex class to perform the following operations:

  • Determinare se una stringa corrisponde a un criterio di espressione regolare.Determine whether a string matches a regular expression pattern.

  • Estrarre una singola corrispondenza o la prima corrispondenza.Extract a single match or the first match.

  • Estrarre tutte le corrispondenze.Extract all matches.

  • Sostituire una sottostringa con corrispondenza.Replace a matched substring.

  • Suddividere una singola stringa in una matrice di stringhe.Split a single string into an array of strings.

Queste operazioni sono descritte nelle sezioni seguenti.These operations are described in the following sections.

Corrispondenza con un criterio di espressione regolareMatching a Regular Expression Pattern

Il metodo Regex.IsMatch restituisce true se la stringa corrisponde al modello. In caso contrario, false.The Regex.IsMatch method returns true if the string matches the pattern, or false if it does not. Il metodo IsMatch è usato spesso per convalidare l'input di stringa.The IsMatch method is often used to validate string input. Ad esempio, il codice seguente assicura che una stringa corrisponda a un numero di previdenza sociale negli Stati Uniti.For example, the following code ensures that a string matches a valid social security number in the United States.

using System;
using System.Text.RegularExpressions;

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

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

Il criterio di ricerca di espressioni regolari ^\d{3}-\d{2}-\d{4}$ è interpretato nel modo illustrato nella tabella seguente.The regular expression pattern ^\d{3}-\d{2}-\d{4}$ is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
^ Trova la corrispondenza con l'inizio della stringa di input.Match the beginning of the input string.
\d{3} Trova la corrispondenza con tre cifre decimali.Match three decimal digits.
- Trova la corrispondenza con un segno meno.Match a hyphen.
\d{2} Trova la corrispondenza con due cifre decimali.Match two decimal digits.
- Trova la corrispondenza con un segno meno.Match a hyphen.
\d{4} Trova la corrispondenza con quattro cifre decimali.Match four decimal digits.
$ Trova la corrispondenza con la fine della stringa di input.Match the end of the input string.

Estrazione di una singola corrispondenza o della prima corrispondenzaExtracting a Single Match or the First Match

Il metodo Regex.Match restituisce un oggetto Match che include informazioni sulla prima sottostringa corrispondente a un criterio di espressione regolare.The Regex.Match method returns a Match object that contains information about the first substring that matches a regular expression pattern. Se la proprietà Match.Success restituisce true, indicando che è stata rilevata una corrispondenza, sarà possibile ottenere informazioni sulle corrispondenze successive chiamando il metodo Match.NextMatch.If the Match.Success property returns true, indicating that a match was found, you can retrieve information about subsequent matches by calling the Match.NextMatch method. Le chiamate ai metodi possono continuare finché la proprietà Match.Success non restituisce false.These method calls can continue until the Match.Success property returns false. Ad esempio, il codice seguente usa il metodo Regex.Match(String, String) per trovare la prima occorrenza di una parola duplicata in una stringa.For example, the following code uses the Regex.Match(String, String) method to find the first occurrence of a duplicated word in a string. Chiama quindi i metodi Match.NextMatch per trovare eventuali occorrenze aggiuntive.It then calls the Match.NextMatch method to find any additional occurrences. L'esempio esamina la proprietà Match.Success dopo ogni chiamata al metodo, per determinare se la corrispondenza corrente è riuscita e se deve essere seguita da una chiamata al metodo Match.NextMatch.The example examines the Match.Success property after each method call to determine whether the current match was successful and whether a call to the Match.NextMatch method should follow.

using System;
using System.Text.RegularExpressions;

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

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

Il criterio di espressione regolare \b(\w+)\W+(\1)\b è interpretato nel modo illustrato nella tabella seguente.The regular expression pattern \b(\w+)\W+(\1)\b is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match on a word boundary.
(\w+) Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\W+ Trova la corrispondenza di uno o più caratteri non alfanumerici.Match one or more non-word characters.
(\1) Trova la corrispondenza con la prima stringa acquisita.Match the first captured string. Equivale al secondo gruppo di acquisizione.This is the second capturing group.
\b Termina la corrispondenza sul confine di parola.End the match on a word boundary.

Estrazione di tutte le corrispondenzeExtracting All Matches

Il metodo Regex.Matches restituisce un oggetto MatchCollection che include informazioni su tutte le corrispondenze rilevate dal motore delle espressioni regolari nella stringa di input.The Regex.Matches method returns a MatchCollection object that contains information about all matches that the regular expression engine found in the input string. Ad esempio, è possibile riscrivere l'esempio precedente in modo da chiamare il metodo Matches invece dei metodi Match e NextMatch.For example, the previous example could be rewritten to call the Matches method instead of the Match and NextMatch methods.

using System;
using System.Text.RegularExpressions;

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

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

Sostituzione di una sottostringa con corrispondenzaReplacing a Matched Substring

Il metodo Regex.Replace sostituisce ogni sottostringa corrispondente al criterio di espressione regolare con una stringa specificata o con un criterio di espressione regolare e restituisce l'intera stringa di input con le sostituzioni.The Regex.Replace method replaces each substring that matches the regular expression pattern with a specified string or regular expression pattern, and returns the entire input string with replacements. Ad esempio, il codice riportato di seguito aggiunge il simbolo di valuta degli Stati Uniti prima di un numero decimale in una stringa.For example, the following code adds a U.S. currency symbol before a decimal number in a string.

using System;
using System.Text.RegularExpressions;

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

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

Il criterio di ricerca di espressioni regolari \b\d+\.\d{2}\b è interpretato nel modo illustrato nella tabella seguente.The regular expression pattern \b\d+\.\d{2}\b is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
\d+ Trova la corrispondenza con una o più cifre decimali.Match one or more decimal digits.
\. Trova la corrispondenza con un punto.Match a period.
\d{2} Trova la corrispondenza con due cifre decimali.Match two decimal digits.
\b Termina la corrispondenza sul confine di parola.End the match at a word boundary.

Il modello di sostituzione $$$& è interpretato nel modo illustrato nella tabella seguente.The replacement pattern $$$& is interpreted as shown in the following table.

ModelloPattern Stringa di sostituzioneReplacement string
$$ Simbolo del dollaro ($).The dollar sign ($) character.
$& Intera stringa corrispondente.The entire matched substring.

Suddivisione di una singola stringa in una matrice di stringheSplitting a Single String into an Array of Strings

Il metodo Regex.Split suddivide la stringa di input nelle posizioni definite da una corrispondenza di espressione regolare.The Regex.Split method splits the input string at the positions defined by a regular expression match. Ad esempio, il codice seguente inserisce gli elementi di un elenco numerato in una matrice di stringhe.For example, the following code places the items in a numbered list into a string array.

using System;
using System.Text.RegularExpressions;

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

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

Il criterio di ricerca di espressioni regolari \b\d{1,2}\.\s è interpretato nel modo illustrato nella tabella seguente.The regular expression pattern \b\d{1,2}\.\s is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
\d{1,2} Trova la corrispondenza con una o due cifre decimali.Match one or two decimal digits.
\. Trova la corrispondenza con un punto.Match a period.
\s Trova la corrispondenza con uno spazio vuoto.Match a white-space character.

Oggetti MatchCollection e MatchThe MatchCollection and Match Objects

I metodi Regex restituiscono due oggetti che fanno parte del modello a oggetti delle espressioni regolari: l'oggetto MatchCollection e l'oggetto Match.Regex methods return two objects that are part of the regular expression object model: the MatchCollection object, and the Match object.

Raccolta MatchThe Match Collection

Il metodo Regex.Matches restituisce un oggetto MatchCollection contenente gli oggetti Match che rappresentano tutte le corrispondenze rilevate dal motore delle espressioni regolari, in base all'ordine in cui si trovano nella stringa di input.The Regex.Matches method returns a MatchCollection object that contains Match objects that represent all the matches that the regular expression engine found, in the order in which they occur in the input string. Se non sono rilevate corrispondenze, il metodo restituisce un oggetto MatchCollection senza membri.If there are no matches, the method returns a MatchCollection object with no members. La proprietà MatchCollection.Item[Int32] permette di accedere a singoli membri della raccolta in base all'indice, da zero al valore della proprietà MatchCollection.Count meno uno.The MatchCollection.Item[Int32] property lets you access individual members of the collection by index, from zero to one less than the value of the MatchCollection.Count property. Item[Int32] è l'indicizzatore della raccolta (in C#) e la proprietà predefinita (in Visual Basic).Item[Int32] is the collection's indexer (in C#) and default property (in Visual Basic).

Per impostazione predefinita, la chiamata al metodo Regex.Matches usa la valutazione lenta per il popolamento dell'oggetto MatchCollection.By default, the call to the Regex.Matches method uses lazy evaluation to populate the MatchCollection object. L'accesso alle proprietà che necessitano di una raccolta completamente popolata, ad esempio le proprietà MatchCollection.Count e MatchCollection.Item[Int32], potrebbe comportare gravi conseguenze per le prestazioni.Access to properties that require a fully populated collection, such as the MatchCollection.Count and MatchCollection.Item[Int32] properties, may involve a performance penalty. È quindi consigliabile accedere alla raccolta usando l'oggetto IEnumerator restituito dal metodo MatchCollection.GetEnumerator.As a result, we recommend that you access the collection by using the IEnumerator object that is returned by the MatchCollection.GetEnumerator method. I singoli linguaggi forniscono i costrutti, ad esempio For``Each in Visual Basic e foreach in C#, che eseguono il wrapping dell'interfaccia IEnumerator della raccolta.Individual languages provide constructs, such as For``Each in Visual Basic and foreach in C#, that wrap the collection's IEnumerator interface.

L'esempio seguente usa il metodo Regex.Matches(String) per popolare un oggetto MatchCollection con tutte le corrispondenze rilevate in una stringa di input.The following example uses the Regex.Matches(String) method to populate a MatchCollection object with all the matches found in an input string. L'esempio enumera la raccolta, copia le corrispondenze a una matrice di stringhe e registra le posizioni dei caratteri in una matrice di valori di tipo Integer.The example enumerates the collection, copies the matches to a string array, and records the character positions in an integer array.

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

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

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

Oggetto MatchThe Match

La classe Match rappresenta il risultato della corrispondenza di una singola espressione regolare.The Match class represents the result of a single regular expression match. È possibile accedere agli oggetti Match in due modi:You can access Match objects in two ways:

  • Tramite il recupero dall'oggetto MatchCollection restituito dal metodo Regex.Matches.By retrieving them from the MatchCollection object that is returned by the Regex.Matches method. Per recuperare i singoli oggetti Match, eseguire l'iterazione della raccolta usando il costrutto foreach (in C#) o .For Each...Next.(in Visual Basic) oppure usare la proprietà MatchCollection.Item[Int32] per recuperare un oggetto Match specifico in base all'indice o al nome.To retrieve individual Match objects, iterate the collection by using a foreach (in C#) or For Each...Next (in Visual Basic) construct, or use the MatchCollection.Item[Int32] property to retrieve a specific Match object either by index or by name. È anche possibile recuperare singoli oggetti Match dalla raccolta eseguendo l'iterazione della raccolta in base all'indice, da zero al numero di oggetti della raccolta meno uno.You can also retrieve individual Match objects from the collection by iterating the collection by index, from zero to one less that the number of objects in the collection. Questo metodo, tuttavia, non permette di avvalersi della valutazione lenta, poiché accede alla proprietà MatchCollection.Count.However, this method does not take advantage of lazy evaluation, because it accesses the MatchCollection.Count property.

    L'esempio seguente recupera singoli oggetti Match da un oggetto MatchCollection eseguendo l'iterazione della raccolta tramite il costrutto foreach o For Each...Next.The following example retrieves individual Match objects from a MatchCollection object by iterating the collection using the foreach or For Each...Next construct. L'espressione regolare corrisponde semplicemente alla stringa "abc" nella stringa di input.The regular expression simply matches the string "abc" in the input string.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "abc";
          string input = "abc123abc456abc789";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine("{0} found at position {1}.", 
                               match.Value, match.Index);
       }
    }
    // The example displays the following output:
    //       abc found at position 0.
    //       abc found at position 6.
    //       abc found at position 12.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As String = "abc"
          Dim input As String = "abc123abc456abc789"
          For Each match As Match In Regex.Matches(input, pattern)
             Console.WriteLine("{0} found at position {1}.", _
                               match.Value, match.Index)
          Next                     
       End Sub
    End Module
    ' The example displays the following output:
    '       abc found at position 0.
    '       abc found at position 6.
    '       abc found at position 12.
    
  • Tramite la chiamata al metodo Regex.Match, che restituisce un oggetto Match che rappresenta la prima corrispondenza in una stringa o in una parte di una stringa.By calling the Regex.Match method, which returns a Match object that represents the first match in a string or a portion of a string. È possibile stabilire se la corrispondenza è stata rilevata tramite il recupero del valore della proprietà Match.Success.You can determine whether the match has been found by retrieving the value of the Match.Success property. Per recuperare gli oggetti Match che rappresentano corrispondenze successive, chiamare ripetutamente il metodo Match.NextMatch, fino a quando la proprietà Success dell'oggetto Match restituito non sarà false.To retrieve Match objects that represent subsequent matches, call the Match.NextMatch method repeatedly, until the Success property of the returned Match object is false.

    L'esempio seguente usa i metodi Regex.Match(String, String) e Match.NextMatch per la corrispondenza con la stringa "abc" nella stringa di input.The following example uses the Regex.Match(String, String) and Match.NextMatch methods to match the string "abc" in the input string.

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

Due proprietà della classe Match restituiscono oggetti della raccolta:Two properties of the Match class return collection objects:

  • La proprietà Match.Groups restituisce un oggetto GroupCollection che include informazioni sulle sottostringhe che corrispondono a gruppi di acquisizione nel criterio di espressione regolare.The Match.Groups property returns a GroupCollection object that contains information about the substrings that match capturing groups in the regular expression pattern.

  • La proprietà Match.Captures restituisce un oggetto CaptureCollection di uso limitato.The Match.Captures property returns a CaptureCollection object that is of limited use. La raccolta non è popolata per un oggetto Match la cui proprietà Success è false.The collection is not populated for a Match object whose Success property is false. In caso contrario, contiene un singolo oggetto Capture che include le stesse informazioni dell'oggetto Match.Otherwise, it contains a single Capture object that has the same information as the Match object.

Per altre informazioni su questi oggetti, vedere le sezioni Raccolta Group e Raccolta Capture più avanti in questo argomento.For more information about these objects, see The Group Collection and The Capture Collection sections later in this topic.

Due proprietà aggiuntive della classe Match forniscono informazioni sulla corrispondenza.Two additional properties of the Match class provide information about the match. La proprietà Match.Value restituisce la sottostringa nella stringa di input corrispondente al criterio di espressione regolare.The Match.Value property returns the substring in the input string that matches the regular expression pattern. La proprietà Match.Index restituisce la posizione di inizio a base zero della stringa con corrispondenza nella stringa di input.The Match.Index property returns the zero-based starting position of the matched string in the input string.

La classe Match include anche due metodi di corrispondenza del modello:The Match class also has two pattern-matching methods:

  • Il metodo Match.NextMatch trova la corrispondenza dopo la corrispondenza rappresentata dall'oggetto corrente Match e restituisce un oggetto Match che rappresenta quella corrispondenza.The Match.NextMatch method finds the match after the match represented by the current Match object, and returns a Match object that represents that match.

  • Il metodo Match.Result esegue un'operazione di sostituzione specificata nella stringa con corrispondenza e restituisce il risultato.The Match.Result method performs a specified replacement operation on the matched string and returns the result.

L'esempio seguente usa il metodo Match.Result per aggiungere un simbolo $ e uno spazio davanti a qualsiasi numero che include due cifre frazionarie.The following example uses the Match.Result method to prepend a $ symbol and a space before every number that includes two fractional digits.

using System;
using System.Text.RegularExpressions;

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

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

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

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

Il criterio di espressione regolare \b\d+(,\d{3})*\.\d{2}\b è definito nel modo illustrato nella tabella seguente.The regular expression pattern \b\d+(,\d{3})*\.\d{2}\b is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
\d+ Trova la corrispondenza con una o più cifre decimali.Match one or more decimal digits.
(,\d{3})* Trova la corrispondenza con zero o più occorrenze di una virgola seguita da tre cifre decimali.Match zero or more occurrences of a comma followed by three decimal digits.
\. Trova la corrispondenza con il carattere del separatore decimale.Match the decimal point character.
\d{2} Trova la corrispondenza con due cifre decimali.Match two decimal digits.
\b Termina la corrispondenza sul confine di parola.End the match at a word boundary.

Il modello di sostituzione $$ $& indica che la stringa con corrispondenza deve essere sostituita da un simbolo del dollaro ($) (modello $$), uno spazio e il valore della corrispondenza (modello $&).The replacement pattern $$ $& indicates that the matched substring should be replaced by a dollar sign ($) symbol (the $$ pattern), a space, and the value of the match (the $& pattern).

Torna all'inizioBack to top

Raccolta GroupThe Group Collection

La proprietà Match.Groups restituisce un oggetto GroupCollection che include gli oggetti Group che rappresentano i gruppi acquisiti in una singola corrispondenza.The Match.Groups property returns a GroupCollection object that contains Group objects that represent captured groups in a single match. Il primo oggetto Group della raccolta (in corrispondenza dell'indice 0) rappresenta l'intera corrispondenza.The first Group object in the collection (at index 0) represents the entire match. Ogni oggetto successivo rappresenta i risultati di un singolo gruppo di acquisizione.Each object that follows represents the results of a single capturing group.

È possibile recuperare singoli oggetti Group nella raccolta usando la proprietà GroupCollection.Item[String].You can retrieve individual Group objects in the collection by using the GroupCollection.Item[String] property. I gruppi senza nome possono essere recuperati in base alla relativa posizione ordinale nella raccolta e i gruppi con nome possono essere recuperati in base al nome o alla posizione ordinale.You can retrieve unnamed groups by their ordinal position in the collection, and retrieve named groups either by name or by ordinal position. Le acquisizioni senza nome compaiono per prime nella raccolta e sono indicizzate da sinistra a destra nell'ordine di visualizzazione nel criterio di espressione regolare.Unnamed captures appear first in the collection, and are indexed from left to right in the order in which they appear in the regular expression pattern. Le acquisizioni con nome sono indicizzate dopo le acquisizioni senza nome, da sinistra a destra nell'ordine di visualizzazione nel criterio di espressione regolare.Named captures are indexed after unnamed captures, from left to right in the order in which they appear in the regular expression pattern. Per determinare i gruppi numerati disponibili nella raccolta restituita per un metodo specifico di corrispondenza con l'espressione regolare, è possibile chiamare il metodo Regex.GetGroupNumbers dell'istanza.To determine what numbered groups are available in the collection returned for a particular regular expression matching method, you can call the instance Regex.GetGroupNumbers method. Per determinare i gruppi con nome disponibili nella raccolta, è possibile chiamare il metodo Regex.GetGroupNames dell'istanza.To determine what named groups are available in the collection, you can call the instance Regex.GetGroupNames method. Entrambi i metodi sono particolarmente utili in routine di uso generale, che analizzano le corrispondenze rilevate da un'espressione regolare.Both methods are particularly useful in general-purpose routines that analyze the matches found by any regular expression.

La proprietà GroupCollection.Item[String] è l'indicizzatore della raccolta in C# e la proprietà predefinita dell'oggetto della raccolta in Visual Basic.The GroupCollection.Item[String] property is the indexer of the collection in C# and the collection object's default property in Visual Basic. È quindi possibile accedere ai singoli oggetti Group in base all'indice oppure in base al nome, nel caso dei gruppi con nome, come indicato di seguito:This means that individual Group objects can be accessed by index (or by name, in the case of named groups) as follows:

Group group = match.Groups[ctr];         
Dim group As Group = match.Groups(ctr)         

L'esempio seguente definisce un'espressione regolare che usa costrutti di raggruppamento per acquisire il mese, il giorno e l'anno di una data.The following example defines a regular expression that uses grouping constructs to capture the month, day, and year of a date.

using System;
using System.Text.RegularExpressions;

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

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

Il criterio di ricerca di espressioni regolari \b(\w+)\s(\d{1,2}),\s(\d{4})\b è definito nel modo illustrato nella tabella seguente.The regular expression pattern \b(\w+)\s(\d{1,2}),\s(\d{4})\b is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
(\w+) Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\s Trova la corrispondenza con uno spazio vuoto.Match a white-space character.
(\d{1,2}) Trova la corrispondenza con una o due cifre decimali.Match one or two decimal digits. Equivale al secondo gruppo di acquisizione.This is the second capturing group.
, Trova la corrispondenza con una virgola.Match a comma.
\s Trova la corrispondenza con uno spazio vuoto.Match a white-space character.
(\d{4}) Trova la corrispondenza con quattro cifre decimali.Match four decimal digits. Equivale al terzo gruppo di acquisizione.This is the third capturing group.
\b Termina la corrispondenza sul confine di parola.End the match on a word boundary.

Torna all'inizioBack to top

Gruppo CapturedThe Captured Group

La classe Group rappresenta il risultato di un singolo gruppo di acquisizione.The Group class represents the result from a single capturing group. Gli oggetti di gruppo che rappresentano i gruppi di acquisizione definiti in un'espressione regolare sono restituiti dalla proprietà Item[String] dell'oggetto GroupCollection restituito dalla proprietà Match.Groups.Group objects that represent the capturing groups defined in a regular expression are returned by the Item[String] property of the GroupCollection object returned by the Match.Groups property. La proprietà Item[String] è l'indicizzatore (in C#) e la proprietà predefinita (in Visual Basic) della classe Group.The Item[String] property is the indexer (in C#) and the default property (in Visual Basic) of the Group class. È anche possibile recuperare i singoli membri eseguendo l'iterazione della raccolta mediante il costrutto foreach o For``Each.You can also retrieve individual members by iterating the collection using the foreach or For``Each construct. Per un esempio, vedere la sezione precedente.For an example, see the previous section.

L'esempio seguente usa i costrutti di raggruppamento annidati per acquisire le sottostringhe nei gruppi.The following example uses nested grouping constructs to capture substrings into groups. Il criterio di espressione regolare (a(b))c corrisponde alla stringa "abc".The regular expression pattern (a(b))c matches the string "abc". Assegna la sottostringa "ab" al primo gruppo di acquisizione e la sottostringa "b" al secondo gruppo di acquisizione.It assigns the substring "ab" to the first capturing group, and the substring "b" to the second capturing group.

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

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
   Console.WriteLine("{0} at position {1}", 
                     results[ctr], matchposition[ctr]);
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4
 Dim matchposition As New List(Of Integer)
 Dim results As New List(Of String)
 ' Define substrings abc, ab, b.
 Dim r As New Regex("(a(b))c") 
 Dim m As Match = r.Match("abdabc")
 Dim i As Integer = 0
 While Not (m.Groups(i).Value = "")    
    ' Add groups to string array.
    results.Add(m.Groups(i).Value)     
    ' Record character position. 
    matchposition.Add(m.Groups(i).Index) 
     i += 1
 End While
 
 ' Display the capture groups.
 For ctr As Integer = 0 to results.Count - 1
    Console.WriteLine("{0} at position {1}", _ 
                      results(ctr), matchposition(ctr))
 Next                     
' The example displays the following output:
'       abc at position 3
'       ab at position 3
'       b at position 4

L'esempio seguente usa costrutti di raggruppamento con nome per acquisire sottostringhe da una stringa che include dati nel formato "DATANAME:VALUE" e viene suddivisa in corrispondenza dei due punti (:) dall'espressione regolare.The following example uses named grouping constructs to capture substrings from a string that contains data in the format "DATANAME:VALUE", which the regular expression splits at the colon (:).

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

Il criterio di ricerca di espressioni regolari ^(?<name>\w+):(?<value>\w+) è definito nel modo illustrato nella tabella seguente.The regular expression pattern ^(?<name>\w+):(?<value>\w+) is defined as shown in the following table.

ModelloPattern DescrizioneDescription
^ Inizia la corrispondenza all'inizio della stringa di input.Begin the match at the beginning of the input string.
(?<name>\w+) Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters. Il nome di questo gruppo di acquisizione è name.The name of this capturing group is name.
: Trova la corrispondenza con i due punti.Match a colon.
(?<value>\w+) Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters. Il nome di questo gruppo di acquisizione è value.The name of this capturing group is value.

Le proprietà della classe Group forniscono informazioni sul gruppo acquisito. La proprietà Group.Value include la sottostringa acquisita, la proprietàGroup.Index indica la posizione iniziale del gruppo acquisito nel testo di input, la proprietà Group.Length include la lunghezza del testo acquisito e la proprietà Group.Success indica se una sottostringa corrisponde al modello definito dal gruppo di acquisizione.The properties of the Group class provide information about the captured group: The Group.Value property contains the captured substring, the Group.Index property indicates the starting position of the captured group in the input text, the Group.Length property contains the length of the captured text, and the Group.Success property indicates whether a substring matched the pattern defined by the capturing group.

L'applicazione di quantificatori a un gruppo (per altre informazioni, vedere Quantificatori) modifica la relazione di un'acquisizione per ogni gruppo di acquisizione in due modi:Applying quantifiers to a group (for more information, see Quantifiers) modifies the relationship of one capture per capturing group in two ways:

  • Se il quantificatore * o *? (che specifica zero o più corrispondenze) è applicato a un gruppo, è possibile che per un gruppo di acquisizione non siano rilevate corrispondenze nella stringa di input.If the * or *? quantifier (which specifies zero or more matches) is applied to a group, a capturing group may not have a match in the input string. Se non è presente testo acquisito, le proprietà dell'oggetto Group sono impostate come mostrato nella tabella seguente.When there is no captured text, the properties of the Group object are set as shown in the following table.

    Proprietà del gruppoGroup property ValoreValue
    Success false
    Value String.Empty
    Length 00

    Nell'esempio seguente viene illustrato questo concetto.The following example provides an illustration. Nel criterio di espressione regolare aaa(bbb)*ccc per il primo gruppo di acquisizione (sottostringa "bbb") possono essere rilevate zero o più corrispondenze.In the regular expression pattern aaa(bbb)*ccc, the first capturing group (the substring "bbb") can be matched zero or more times. Poiché la stringa di input "aaaccc" corrisponde al modello, per il gruppo di acquisizione non sono rilevate corrispondenze.Because the input string "aaaccc" matches the pattern, the capturing group does not have a match.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "aaa(bbb)*ccc";
          string input = "aaaccc";
          Match match = Regex.Match(input, pattern);
          Console.WriteLine("Match value: {0}", match.Value);
          if (match.Groups[1].Success)
             Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value);
          else
             Console.WriteLine("The first capturing group has no match.");
       }
    }
    // The example displays the following output:
    //       Match value: aaaccc
    //       The first capturing group has no match.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As String = "aaa(bbb)*ccc"
          Dim input As String = "aaaccc"
          Dim match As Match = Regex.Match(input, pattern)
          Console.WriteLine("Match value: {0}", match.Value)
          If match.Groups(1).Success Then
             Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value)
          Else
             Console.WriteLine("The first capturing group has no match.")
         End If   
       End Sub
    End Module
    ' The example displays the following output:
    '       Match value: aaaccc
    '       The first capturing group has no match.
    
  • I quantificatori possono corrispondere a più occorrenze di un modello definito da un gruppo di acquisizione.Quantifiers can match multiple occurrences of a pattern that is defined by a capturing group. In questo caso, le proprietà Value e Length di un oggetto Group contengono informazioni sull'ultima sottostringa acquisita.In this case, the Value and Length properties of a Group object contain information only about the last captured substring. Ad esempio, l'espressione regolare seguente corrisponde a una singola frase che termina con un punto.For example, the following regular expression matches a single sentence that ends in a period. Usa due costrutti di raggruppamento: il primo acquisisce singole parole insieme a un carattere di spaziatura e il secondo acquisisce le singole parole.It uses two grouping constructs: The first captures individual words along with a white-space character; the second captures individual words. Come illustrato dall'output dell'esempio, anche se l'espressione regolare riesce ad acquisire un'intera frase, il secondo gruppo di acquisizione acquisisce solo l'ultima parola.As the output from the example shows, although the regular expression succeeds in capturing an entire sentence, the second capturing group captures only the last word.

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

Torna all'inizioBack to top

Raccolta CaptureThe Capture Collection

L'oggetto Group include informazioni solo sull'ultima acquisizione.The Group object contains information only about the last capture. L'intero set di acquisizioni eseguite da un gruppo di acquisizione è tuttavia ancora disponibile tramite l'oggetto CaptureCollection restituito dalla proprietà Group.Captures.However, the entire set of captures made by a capturing group is still available from the CaptureCollection object that is returned by the Group.Captures property. Ogni membro della raccolta è un oggetto Capture che rappresenta un'acquisizione eseguita da quel gruppo di acquisizione, in base all'ordine di acquisizione e quindi in base all'ordine in cui sono state rilevate corrispondenze per le stringhe acquisite da sinistra a destra nella stringa di input.Each member of the collection is a Capture object that represents a capture made by that capturing group, in the order in which they were captured (and, therefore, in the order in which the captured strings were matched from left to right in the input string). È possibile recuperare singoli oggetti Capture dalla raccolta in uno dei due modi seguenti:You can retrieve individual Capture objects from the collection in either of two ways:

  • Eseguendo un'iterazione nella raccolta tramite un costrutto, ad esempio foreach (in C#) o For``Each (in Visual Basic).By iterating through the collection using a construct such as foreach (in C#) or For``Each (in Visual Basic).

  • Usando la proprietà CaptureCollection.Item[Int32] per recuperare un oggetto specifico in base all'indice.By using the CaptureCollection.Item[Int32] property to retrieve a specific object by index. La proprietà Item[Int32] è la proprietà predefinita (in Visual Basic) o l'indicizzatore (in C#) dell'oggetto CaptureCollection.The Item[Int32] property is the CaptureCollection object's default property (in Visual Basic) or indexer (in C#).

Se a un gruppo di acquisizione non è applicato alcun quantificatore, l'oggetto CaptureCollection conterrà un singolo oggetto Capture di scarso interesse, poiché fornisce informazioni sulla stessa corrispondenza indicata dall'oggetto Group.If a quantifier is not applied to a capturing group, the CaptureCollection object contains a single Capture object that is of little interest, because it provides information about the same match as its Group object. Se a un gruppo di acquisizione è applicato un quantificatore, l'oggetto CaptureCollection conterrà tutte le acquisizioni eseguite dal gruppo di acquisizione e l'ultimo membro della raccolta rappresenterà la stessa acquisizione indicata dall'oggetto Group.If a quantifier is applied to a capturing group, the CaptureCollection object contains all captures made by the capturing group, and the last member of the collection represents the same capture as the Group object.

Ad esempio, se si usa il criterio di espressione regolare ((a(b))c)+, in cui il quantificatore + specifica una o più corrispondenze, per acquisire corrispondenze dalla stringa "abcabcabc", l'oggetto CaptureCollection per ogni oggetto Group includerà tre membri.For example, if you use the regular expression pattern ((a(b))c)+ (where the + quantifier specifies one or more matches) to capture matches from the string "abcabcabc", the CaptureCollection object for each Group object contains three members.

using System;
using System.Text.RegularExpressions;

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

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

L'esempio seguente usa l'espressione regolare (Abc)+ per trovare una o più esecuzioni consecutive della stringa "Abc" nella stringa "XYZAbcAbcAbcXYZAbcAb".The following example uses the regular expression (Abc)+ to find one or more consecutive runs of the string "Abc" in the string "XYZAbcAbcAbcXYZAbcAb". L'esempio illustra l'uso della proprietà Group.Captures per restituire più gruppi di sottostringhe acquisite.The example illustrates the use of the Group.Captures property to return multiple groups of captured substrings.

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

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

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

   // Loop through each group.
   for (int i=0; i < gc.Count; i++) 
   {
      cc = gc[i].Captures;
      counter = cc.Count;
       
      // Display the number of captures in this group.
      Console.WriteLine("Captures count = " + counter.ToString());
       
      // Loop through each capture in the group.
      for (int ii = 0; ii < counter; ii++) 
      {
         // Display the capture and its position.
         Console.WriteLine(cc[ii] + "   Starts at character " + 
              cc[ii].Index);
      }
   }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9  
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection

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

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

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

Torna all'inizioBack to top

Singola acquisizioneThe Individual Capture

La classe Capture include i risultati di una singola acquisizione di sottoespressione.The Capture class contains the results from a single subexpression capture. La proprietà Capture.Value include il testo con corrispondenza e la proprietà Capture.Index indica la posizione a base zero nella stringa di input in cui inizia la sottostringa con corrispondenza.The Capture.Value property contains the matched text, and the Capture.Index property indicates the zero-based position in the input string at which the matched substring begins.

L'esempio seguente analizza una stringa di input per ottenere la temperatura di città selezionate.The following example parses an input string for the temperature of selected cities. Una città e la relativa temperatura sono separate da una virgola (",") e un punto e virgola (";") separa i dati di ogni città.A comma (",") is used to separate a city and its temperature, and a semicolon (";") is used to separate each city's data. L'intera stringa di input rappresenta una singola corrispondenza.The entire input string represents a single match. Nel criterio di espressione regolare ((\w+(\s\w+)*),(\d+);)+, usato per analizzare la stringa, il nome della città è assegnato al secondo gruppo di acquisizione e la temperatura al quarto.In the regular expression pattern ((\w+(\s\w+)*),(\d+);)+, which is used to parse the string, the city name is assigned to the second capturing group, and the temperature is assigned to the fourth capturing group.

using System;
using System.Text.RegularExpressions;

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

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

L'espressione regolare è definita nel modo illustrato nella tabella seguente.The regular expression is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\w+ Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters.
(\s\w+)* Trova la corrispondenza con zero o più occorrenze di un carattere di spaziatura seguito da uno o più caratteri di parola.Match zero or more occurrences of a white-space character followed by one or more word characters. Questo modello corrisponde a nomi di città composti da più parole.This pattern matches multi-word city names. Equivale al terzo gruppo di acquisizione.This is the third capturing group.
(\w+(\s\w+)*) Trova la corrispondenza con uno o più caratteri di parola seguiti da zero o più caratteri di spaziatura e uno o più caratteri di parola.Match one or more word characters followed by zero or more occurrences of a white-space character and one or more word characters. Equivale al secondo gruppo di acquisizione.This is the second capturing group.
, Trova la corrispondenza con una virgola.Match a comma.
(\d+) Trova la corrispondenza con una o più cifre.Match one or more digits. Questo è il quarto gruppo di acquisizione.This is the fourth capturing group.
; Trova la corrispondenza con un punto e virgola.Match a semicolon.
((\w+(\s\w+)*),(\d+);)+ Trova la corrispondenza con modello di una parola seguita da parole aggiuntive seguite da una virgola, una o più cifre e un punto e virgola, una o più volte.Match the pattern of a word followed by any additional words followed by a comma, one or more digits, and a semicolon, one or more times. Equivale al primo gruppo di acquisizione.This is the first capturing group.

Vedere ancheSee Also

System.Text.RegularExpressions
Espressioni regolari .NET.NET Regular Expressions
Linguaggio di espressioni regolari - Riferimento rapidoRegular Expression Language - Quick Reference