Group.Captures Eigenschaft

public:
 property System::Text::RegularExpressions::CaptureCollection ^ Captures { System::Text::RegularExpressions::CaptureCollection ^ get(); };

public System.Text.RegularExpressions.CaptureCollection Captures { get; }

member this.Captures : System.Text.RegularExpressions.CaptureCollection

Public ReadOnly Property Captures As CaptureCollection

Eigenschaftswert

Die Sammlung von Teilzeichenfolgen, die von der Gruppe abgeglichen werden.

Hinweise

Wenn ein Quantifizierer nicht auf eine Aufnahmegruppe angewendet wird, enthält die von der Captures Eigenschaft zurückgegebene Auflistung ein einzelnes Capture Objekt, das Informationen zur gleichen Teilzeichenfolge wie das Group Objekt bereitstellt. Dies wird im folgenden Beispiel veranschaulicht. Er definiert einen regulären Ausdruck, \b(\w+)\bder ein einzelnes Wort aus einem Satz extrahiert. Das Group Objekt erfasst das Wort "This", und das einzelne Objekt in der CaptureCollection Datei enthält Informationen zur gleichen Erfassung.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\b";
      string input = "This is one sentence.";
      Match match = Regex.Match(input, pattern);
      if (match.Success) {
         Console.WriteLine("Matched text: {0}", match.Value);
         for (int ctr = 1; ctr <= match.Groups.Count - 1; ctr++) {
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups[ctr].Value);
            int captureCtr = 0;
            foreach (Capture capture in match.Groups[ctr].Captures) {
               Console.WriteLine("      Capture {0}: {1}", 
                                 captureCtr, capture.Value);
               captureCtr += 1;                  
            }
         }
      }   
   }
}
// The example displays the following output:
//       Matched text: This
//          Group 1:  This
//             Capture 0: This

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)\b"
      Dim input As String = "This is one sentence."
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Matched text: {0}", match.Value)
         For ctr As Integer = 1 To match.Groups.Count - 1
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups(ctr).Value)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In match.Groups(ctr).Captures
               Console.WriteLine("      Capture {0}: {1}", _
                                 captureCtr, capture.Value)
               captureCtr += 1                  
            Next
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Matched text: This
'          Group 1:  This
'             Capture 0: This

Das eigentliche Dienstprogramm der Captures Eigenschaft tritt auf, wenn ein Quantifizierer auf eine Aufnahmegruppe angewendet wird, sodass die Gruppe mehrere Teilzeichenfolgen in einem einzelnen regulären Ausdruck erfasst. In diesem Fall enthält das Group Objekt Informationen zur letzten erfassten Teilzeichenfolge, während die Captures Eigenschaft Informationen zu allen teilzeichenfolgen enthält, die von der Gruppe erfasst werden. Im folgenden Beispiel entspricht der reguläre Ausdruck \b(\w+\s*)+\. einem ganzen Satz, der in einem Punkt endet. Die Gruppe (\w+\s*)+ erfasst die einzelnen Wörter in der Auflistung. Da die Group Sammlung nur Informationen über die letzte erfasste Teilzeichenfolge enthält, erfasst sie das letzte Wort im Satz "Sentence". Jedes von der Gruppe erfasste Wort steht jedoch in der von der Captures Eigenschaft zurückgegebenen Auflistung zur Verfügung.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a sentence. This is another sentence.";
      string pattern = @"\b(\w+\s*)+\.";
      Match match = Regex.Match(input, pattern);
      if (match.Success) {
         Console.WriteLine("Matched text: {0}", match.Value);
         for (int ctr = 1; ctr < match.Groups.Count; ctr++) {
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups[ctr].Value);
            int captureCtr = 0;
            foreach (Capture capture in match.Groups[ctr].Captures) {
               Console.WriteLine("      Capture {0}: {1}", 
                                 captureCtr, capture.Value);
               captureCtr++; 
            }
         }
      }   
   }
}
// The example displays the following output:
//       Matched text: This is a sentence.
//          Group 1:  sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: sentence

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is a sentence. This is another sentence."
      Dim pattern As String = "\b(\w+\s*)+\."
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Matched text: {0}", match.Value)
         For ctr As Integer = 1 To match.Groups.Count - 1
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups(ctr).Value)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In match.Groups(ctr).Captures
               Console.WriteLine("      Capture {0}: {1}", _
                                 captureCtr, capture.Value)
               captureCtr += 1                  
            Next
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Matched text: This is a sentence.
'          Group 1:  sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: sentence

Weitere Informationen

• Gruppieren von Konstrukten in regulären Ausdrücken
• Quantifizierer in regulären Ausdrücken