Regex.GroupNameFromNumber(Int32) Metodo

public:
 System::String ^ GroupNameFromNumber(int i);

public string GroupNameFromNumber(int i);

member this.GroupNameFromNumber : int -> string

Public Function GroupNameFromNumber (i As Integer) As String

Parametri

Restituisce

Stringa contenente il nome del gruppo associato al numero di gruppo specificato. Se non esiste alcun nome di gruppo che corrisponde a i, il metodo restituisce Empty.

Esempio

Nell'esempio seguente viene definito un criterio di espressione regolare che corrisponde a una riga di indirizzo contenente un nome, un nome di città degli Stati Uniti, un nome di stato e un codice postale. Nell'esempio viene utilizzato il GroupNameFromNumber metodo per recuperare i nomi dei gruppi di acquisizione. Usa quindi questi nomi per recuperare i gruppi acquisiti corrispondenti per le corrispondenze.

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

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<city>[A-Za-z\s]+), (?<state>[A-Za-z]{2}) (?<zip>\d{5}(-\d{4})?)";
      string[] cityLines = {"New York, NY 10003", "Brooklyn, NY 11238", "Detroit, MI 48204", 
                            "San Francisco, CA 94109", "Seattle, WA 98109" };
      Regex rgx = new Regex(pattern);
      List<string> names = new List<string>();
      int ctr = 1;
      bool exitFlag = false;
      // Get group names.
      do {
         string name = rgx.GroupNameFromNumber(ctr);
         if (!String.IsNullOrEmpty(name))
         {
            ctr++;
            names.Add(name);
         }
         else
         {
            exitFlag = true;
         }
      } while (!exitFlag);

      foreach (string cityLine in cityLines)
      {
         Match match = rgx.Match(cityLine);
         if (match.Success)
            Console.WriteLine("Zip code {0} is in {1}, {2}.", 
                               match.Groups[names[3]], 
                               match.Groups[names[1]], 
                               match.Groups[names[2]]);
      } 
   }
}
// The example displays the following output:
//       Zip code 10003 is in New York, NY.
//       Zip code 11238 is in Brooklyn, NY.
//       Zip code 48204 is in Detroit, MI.
//       Zip code 94109 is in San Francisco, CA.
//       Zip code 98109 is in Seattle, WA.

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

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<city>[A-Za-z\s]+), (?<state>[A-Za-z]{2}) (?<zip>\d{5}(-\d{4})?)"
      Dim cityLines() As String = {"New York, NY 10003", "Brooklyn, NY 11238", "Detroit, MI 48204", _
                                   "San Francisco, CA 94109", "Seattle, WA 98109" }
      Dim rgx As New Regex(pattern)
      Dim names As New List(Of String)      
      Dim ctr As Integer = 1
      Dim exitFlag As Boolean = False
      ' Get group names.
      Do 
         Dim name As String = rgx.GroupNameFromNumber(ctr)
         If Not String.IsNullOrEmpty(name) Then
            ctr += 1
            names.Add(name)
         Else
            exitFlag = True
         End If
      Loop While Not exitFlag
      
      For Each cityLine As String In cityLines
         Dim match As Match = rgx.Match(cityLine)
         If match.Success Then
            Console.WriteLine("Zip code {0} is in {1}, {2}.", _
                               match.Groups.Item(names.Item(3)), _
                               match.Groups.Item(names.Item(1)), _
                               match.Groups.Item(names.Item(2)))
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'       Zip code 10003 is in New York, NY.
'       Zip code 11238 is in Brooklyn, NY.
'       Zip code 48204 is in Detroit, MI.
'       Zip code 94109 is in San Francisco, CA.
'       Zip code 98109 is in Seattle, WA.

Il criterio di espressione regolare è definito dall'espressione seguente:

(?<city>[A-Za-z\s]+), (?<state>[A-Za-z]{2}) (?<zip>\d{5}(-\d{4})?)

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Commenti

Un criterio di espressione regolare può contenere gruppi di acquisizione denominati o numerati, che delineano sottoespressioni all'interno di una corrispondenza dei criteri. I gruppi numerati sono delimitati dalla sintassi (sottoespressione) e vengono assegnati numeri in base al relativo ordine nell'espressione regolare. I gruppi denominati sono delimitati dalla sintassi (?<Nome>sottoespressione) o (?' name'subexpression), dove name è il nome in base al quale verrà identificata la sottoespressione. Per altre informazioni, vedere Costrutti di raggruppamento. Il GroupNameFromNumber metodo identifica sia i gruppi denominati che i gruppi numerati in base alle rispettive posizioni ordinali nell'espressione regolare. La posizione ordinale zero rappresenta sempre l'intera espressione regolare. Tutti i gruppi numerati vengono quindi conteggiati prima dei gruppi denominati, indipendentemente dalla posizione effettiva nel criterio di espressione regolare.

Se i è il numero di un gruppo denominato, il metodo restituisce il nome del gruppo. Se i è il numero di un gruppo senza nome, il metodo restituisce la rappresentazione di stringa del numero. Ad esempio, se i è 1, il metodo restituisce "1". Se i non è il numero di un gruppo di acquisizione, il metodo restituisce String.Empty.

Se viene trovata una corrispondenza del criterio, è possibile utilizzare il valore restituito da questo metodo per recuperare l'oggetto Group che rappresenta il gruppo acquisito dalla GroupCollection.Item[] proprietà . L'oggetto GroupCollection viene restituito dalla Match.Groups proprietà .

Vedi anche

• GroupCollection
• GetGroupNumbers()
• Costrutti di raggruppamento nelle espressioni regolari