Regex.GetGroupNumbers Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Origine:: Regex.cs

Origine:: Regex.cs

Origine:: Regex.cs

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.

Restituisce una matrice di numeri di gruppi di acquisizione che corrispondono ai nomi dei gruppi in una matrice.

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

public int[] GetGroupNumbers ();

member this.GetGroupNumbers : unit -> int[]

Public Function GetGroupNumbers () As Integer()

Restituisce

Int32[]

Matrice di interi di numeri di gruppi.

Esempio

Nell'esempio seguente viene definita un'espressione regolare, \b((?<word>\w+)\s*)+(?<end>[.?!]), che corrisponde a una frase. L'espressione regolare include tre gruppi di acquisizione: un gruppo senza nome che acquisisce una singola parola insieme a un carattere di spazio che può seguirlo; un gruppo denominato word che acquisisce le singole parole nella frase e un gruppo denominato end che acquisisce la punteggiatura che termina la frase. Nell'esempio viene chiamato il GetGroupNumbers metodo per ottenere i numeri di tutti i gruppi di acquisizione e quindi viene visualizzata la stringa acquisita. Inoltre, il GroupNameFromNumber metodo viene usato per indicare se un determinato gruppo numerato corrisponde a un gruppo denominato.

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): '.'

Il criterio di ricerca di espressioni regolari viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`(?<word>\w+)`	Trova la corrispondenza di uno o più caratteri di parola e assegna le stringhe corrispondenti a un gruppo denominato `word`.
`\s*`	Trovare la corrispondenza di zero o più spazi vuoti.
`((?<word>\w+)\s*)`	Assegnare il `word` gruppo acquisito seguito da eventuali caratteri di spazio vuoto acquisiti al primo gruppo acquisito.
`((?<word>\w+)\s*)+`	Trova la corrispondenza con il modello di uno o più caratteri di parola seguiti da uno o più caratteri di spazio vuoto una o più volte.
`(?<end>[.?!])`	Trova la corrispondenza di un punto, un punto interrogativo o un punto esclamativo. Assegnare il carattere corrispondente al `end` gruppo di acquisizione.

Commenti

È possibile accedere sia ai gruppi di acquisizione senza nome che ai gruppi di acquisizione denominati in base al numero. I gruppi senza nome vengono numerati da sinistra a destra a partire da 1. Il gruppo di acquisizione nell'indice 0 (zero) rappresenta la corrispondenza nel suo complesso. I gruppi denominati vengono quindi numerati da sinistra a destra a partire da un numero maggiore del numero di gruppi di acquisizione senza nome.

Fare riferimento a un gruppo in base al numero anziché in base al nome stringa può fornire un accesso più rapido.

Si applica a

Condividi tramite