Regex.GetGroupNumbers Methode

Referenz

Definition

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Gibt ein Array der Nummern von Erfassungsgruppen zurück, die den Gruppennamen in einem Array entsprechen.

public:
 cli::array <int> ^ GetGroupNumbers();

public int[] GetGroupNumbers ();

member this.GetGroupNumbers : unit -> int[]

Public Function GetGroupNumbers () As Integer()

Gibt zurück

Int32[]

Ein Ganzzahlarray der Gruppennummern.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, \b((?<word>\w+)\s*)+(?<end>[.?!])der einem Satz entspricht. Der reguläre Ausdruck enthält drei Aufnahmegruppen: eine nicht benannte Gruppe, die ein einzelnes Wort zusammen mit einem Leerzeichen erfasst, das sie befolgen kann; eine Gruppe mit dem Namen word , die die einzelnen Wörter im Satz erfasst, und eine Gruppe mit dem Namen end , mit der die Interpunktion erfasst wird, die den Satz beendet. Im Beispiel wird die GetGroupNumbers Methode aufgerufen, um die Anzahl aller Aufnahmegruppen abzurufen, und zeigt dann die erfasste Zeichenfolge an. Darüber hinaus wird die GroupNameFromNumber Methode verwendet, um anzugeben, ob eine bestimmte nummerierte Gruppe einer benannten Gruppe entspricht.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?<word>\w+)\s*)+(?<end>[.?!])";
      string input = "This is a sentence. This is a second sentence.";
      
      Regex rgx = new Regex(pattern);
      int[] groupNumbers = rgx.GetGroupNumbers();
      Match m = rgx.Match(input);
      if (m.Success) {
         Console.WriteLine("Match: {0}", m.Value);
         foreach (var groupNumber in groupNumbers) {
            string name = rgx.GroupNameFromNumber(groupNumber);
            int number;
            Console.WriteLine("   Group {0}{1}: '{2}'", 
                              groupNumber, 
                              ! string.IsNullOrEmpty(name) & 
                              ! Int32.TryParse(name, out number) ?
                                 " (" + name + ")" : String.Empty, 
                              m.Groups[groupNumber].Value);
         }
      } 
   }
}
// The example displays the following output:
//       Match: This is a sentence.
//          Group 0: 'This is a sentence.'
//          Group 1: 'sentence'
//          Group 2 (word): 'sentence'
//          Group 3 (end): '.'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String= "\b((?<word>\w+)\s*)+(?<end>[.?!])"
      Dim input As String = "This is a sentence. This is a second sentence."
      
      Dim rgx As New Regex(pattern)
      Dim groupNumbers() As Integer = rgx.GetGroupNumbers()
      Dim m As Match = rgx.Match(input)
      If m.Success Then
         Console.WriteLine("Match: {0}", m.Value)
         For Each groupNumber In groupNumbers
            Dim name As String = rgx.GroupNameFromNumber(groupNumber)
            Dim number As Integer
            Console.WriteLine("   Group {0}{1}: '{2}'", 
                              groupNumber, 
                              If(Not String.IsNullOrEmpty(name) And 
                              Not Int32.TryParse(name, number),
                                 " (" + name + ")", String.Empty), 
                              m.Groups(groupNumber).Value)
         Next
      End If 
   End Sub
End Module
' The example displays the following output:
'       Match: This is a sentence.
'          Group 0: 'This is a sentence.'
'          Group 1: 'sentence'
'          Group 2 (word): 'sentence'
'          Group 3 (end): '.'

Das Muster für reguläre Ausdrücke wird entsprechend der folgenden Tabelle interpretiert.

Muster	Beschreibung
`\b`	Der Vergleich beginnt an einer Wortgrenze.
`(?<word>\w+)`	Entspricht einem oder mehreren Wortzeichen, und weisen Sie den übereinstimmenden Zeichenfolgen einer Gruppe namens `word`zu.
`\s*`	Sucht nach 0 (null) oder mehr Leerzeichen.
`((?<word>\w+)\s*)`	Weisen Sie der erfassten Gruppe gefolgt von allen erfassten Leerzeichen die `word` erste erfasste Gruppe zu.
`((?<word>\w+)\s*)+`	Passen Sie das Muster eines oder mehrerer Wortzeichen an, gefolgt von beliebigen Leerzeichen mindestens einmal.
`(?<end>[.?!])`	Übereinstimmung mit einem Punkt, Fragezeichen oder Ausrufezeichen. Weisen Sie dem Erfassen der Gruppe das `end` übereinstimmende Zeichen zu.

Hinweise

Sowohl unbenamete als auch benannte Aufnahmegruppen können nach Nummer zugegriffen werden. Nicht benannte Gruppen werden von links nach rechts nummeriert, beginnend mit 1. (Die Aufnahmegruppe in Index 0 (Null) stellt die Übereinstimmung als Ganzes dar.) Benannte Gruppen werden dann von links nach rechts nummeriert, beginnend mit einer Zahl, die größer als die Anzahl der nicht benannten Aufnahmegruppen ist.

Das Verweisen auf eine Gruppe anhand seiner Zahl anstelle des Zeichenfolgennamens kann schnelleren Zugriff ermöglichen.

Gilt für

Freigeben über