Regex.GroupNameFromNumber(Int32) Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Ottiene un nome di gruppo che corrisponde al numero di gruppo specificato.
public:
System::String ^ GroupNameFromNumber(int i);public string GroupNameFromNumber (int i);member this.GroupNameFromNumber : int -> stringPublic Function GroupNameFromNumber (i As Integer) As StringParametri
- i
- Int32
Numero di gruppo da convertire nel nome di gruppo corrispondente.
Restituisce
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.
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 è 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à .
