Regex.GroupNameFromNumber(Int32) Metodo

Definizione

Spazio dei nomi:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Origine:

Regex.cs

Ottiene un nome di gruppo che corrisponde al numero di gruppo specificato.

public string GroupNameFromNumber (int i);

Parametri

i

Int32

Numero di gruppo da convertire nel nome di gruppo corrispondente.

Restituisce

String

Stringa contenente il nome di gruppo associato al numero di gruppo specificato. Se nessun nome di gruppo corrisponde a i, il metodo restituisce Empty.

Esempio

L'esempio seguente definisce un modello di espressione regolare che corrisponde a una riga di indirizzo contenente un nome, un nome di stato e un codice postale della città degli Stati Uniti. 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.

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 è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.

Modello	Descrizione
(?<city>[A-Za-z\s]+)	Trova la corrispondenza con uno o più caratteri alfabetici o spazi vuoti. Assegnare a questo gruppo acquisito il nome city.
,	Trova la corrispondenza con una virgola (,) seguita da uno spazio vuoto.
(?<state>[A-Za-z]{2})	Trova la corrispondenza con due caratteri alfabetici. Assegnare a questo gruppo acquisito il nome state. Questo gruppo deve essere seguito da uno spazio vuoto.
(?<zip>\d{5}(-\d{4})?)	Trova la corrispondenza con cinque cifre numeriche seguite da zero o da una occorrenza di un trattino seguito da quattro cifre. Assegnare a questo gruppo acquisito il nome zip.

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 all'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. 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à .

Si applica a

Vedi anche

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