Regex.GroupNameFromNumber(Int32) Methode

Definition

Ruft den Gruppennamen ab, der der angegebenen Gruppennummer entspricht.

public:
 System::String ^ GroupNameFromNumber(int i);
public string GroupNameFromNumber (int i);
member this.GroupNameFromNumber : int -> string
Public Function GroupNameFromNumber (i As Integer) As String

Parameter

i
Int32

Die Gruppennummer, die in den entsprechenden Gruppennamen konvertiert werden soll.

Gibt zurück

String

Eine Zeichenfolge, die den Gruppennamen enthält, der der angegebenen Gruppennummer zugeordnet ist. Wenn kein Gruppenname vorhanden ist, der i entspricht, gibt die Methode Empty zurück.

Beispiele

Im folgenden Beispiel wird ein Reguläres Ausdrucksmuster definiert, das einer Adresszeile entspricht, die einen US-Stadtnamen, einen Bundesstaatsnamen und einen Postleitzahlennamen enthält. Im Beispiel wird die GroupNameFromNumber Methode verwendet, um die Namen der Aufnahmegruppen abzurufen. Anschließend werden diese Namen verwendet, um die entsprechenden erfassten Gruppen für Übereinstimmungen abzurufen.

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.

Das Muster für reguläre Ausdrücke wird durch den folgenden Ausdruck definiert:

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

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.

Muster BESCHREIBUNG
(?<city>[A-Za-z\s]+) Stimmen Sie einem oder mehreren alphabetischen oder leerzeichen überein. Weisen Sie diese erfasste Gruppe dem Namen zu city.
, Entspricht einem Komma (,) gefolgt von einem Leerzeichen.
(?<state>[A-Za-z]{2}) Stimmen Sie zwei alphabetische Zeichen überein. Weisen Sie diese erfasste Gruppe dem Namen zu state. Dieser Gruppe sollte ein Leerzeichen folgen.
(?<zip>\d{5}(-\d{4})?) Passen Sie fünf numerische Ziffern an, gefolgt von null oder einem Vorkommen eines Bindestrichs gefolgt von vier Ziffern. Weisen Sie diese erfasste Gruppe dem Namen zu zip.

Hinweise

Ein reguläres Ausdrucksmuster kann entweder benannte oder nummerierte Aufnahmegruppen enthalten, die Subexpressionen innerhalb einer Musterüberstimmung delineieren. Nummerierte Gruppen werden durch die Syntax (Subexpression) getrennt und werden Zahlen basierend auf ihrer Reihenfolge im regulären Ausdruck zugewiesen. Benannte Gruppen werden durch die Syntax getrennt (?< Namen> Subexpression) oder (?' name'subexpression), wobei name der Name der Name ist, mit dem der Unterausdruck identifiziert wird. (Weitere Informationen finden Sie unter Gruppierungskonstrukte.) Die GroupNameFromNumber Methode identifiziert sowohl benannte Gruppen als auch nummerierte Gruppen anhand ihrer Ordnungspositionen im regulären Ausdruck. Ordnungsposition Null stellt immer den gesamten regulären Ausdruck dar. Alle nummerierten Gruppen werden dann vor benannten Gruppen gezählt, unabhängig von ihrer tatsächlichen Position im Regulären Ausdrucksmuster.

Wenn i es sich um die Anzahl einer benannten Gruppe handelt, gibt die Methode den Namen der Gruppe zurück. Wenn i es sich um die Anzahl einer nicht benannten Gruppe handelt, gibt die Methode die Zeichenfolgendarstellung der Zahl zurück. Wenn i die Methode beispielsweise 1 ist, gibt die Methode "1" zurück. Wenn i nicht die Anzahl einer Erfassungsgruppe ist, gibt die Methode zurück String.Empty.

Wenn eine Musterabgleichung gefunden wird, kann der von dieser Methode zurückgegebene Wert verwendet werden, um das Group Objekt abzurufen, das die erfasste Gruppe aus der GroupCollection.Item[] Eigenschaft darstellt. Das GroupCollection Objekt wird von der Match.Groups Eigenschaft zurückgegeben.

Gilt für:

Siehe auch