Capture.Value Eigenschaft

Referenz

Definition

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Quelle:: Capture.cs

Quelle:: Capture.cs

Quelle:: Capture.cs

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.

Ruft die aufgezeichnete Teilzeichenfolge aus der Eingabezeichenfolge ab.

public:
 property System::String ^ Value { System::String ^ get(); };

public string Value { get; }

member this.Value : string

Public ReadOnly Property Value As String

Eigenschaftswert

String

Die Teilzeichenfolge, die von der Übereinstimmung aufgezeichnet wird.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der mit Sätzen übereinstimmt, die außer einem Punkt (".") keine Interpunktion enthalten. Die Match.Value -Eigenschaft zeigt die Ergebniszeichenfolge an, die aus einem übereinstimmenden Satz besteht, für jede Übereinstimmung. Die Group.Value -Eigenschaft zeigt die Ergebniszeichenfolge für jede Erfassungsgruppe an. Sie besteht aus der letzten Zeichenfolge, die von dieser Erfassungsgruppe erfasst wurde. Die Capture.Value -Eigenschaft zeigt die Ergebniszeichenfolge für jede Erfassung an.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Yes. This dog is very friendly.";
      string pattern = @"((\w+)[\s.])+";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("Match: {0}", match.Value);
         for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
         {
            Group group = match.Groups[groupCtr];
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            for (int captureCtr = 0; captureCtr < group.Captures.Count; captureCtr++)
               Console.WriteLine("      Capture {0}: {1}", captureCtr, 
                                 group.Captures[captureCtr].Value);
         }                      
      }
   }
}
// The example displays the following output:
//       Match: Yes.
//          Group 0: Yes.
//             Capture 0: Yes.
//          Group 1: Yes.
//             Capture 0: Yes.
//          Group 2: Yes
//             Capture 0: Yes
//       Match: This dog is very friendly.
//          Group 0: This dog is very friendly.
//             Capture 0: This dog is very friendly.
//          Group 1: friendly.
//             Capture 0: This
//             Capture 1: dog
//             Capture 2: is
//             Capture 3: very
//             Capture 4: friendly.
//          Group 2: friendly
//             Capture 0: This
//             Capture 1: dog
//             Capture 2: is
//             Capture 3: very
//             Capture 4: friendly

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Yes. This dog is very friendly."
      Dim pattern As String = "((\w+)[\s.])+"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Match: {0}", match.Value)
         For groupCtr As Integer = 0 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            For captureCtr As Integer = 0 To group.Captures.Count - 1
               Console.WriteLine("      Capture {0}: {1}", captureCtr, _
                                 group.Captures(captureCtr).Value)
            Next
         Next                      
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: Yes.
'          Group 0: Yes.
'             Capture 0: Yes.
'          Group 1: Yes.
'             Capture 0: Yes.
'          Group 2: Yes
'             Capture 0: Yes
'       Match: This dog is very friendly.
'          Group 0: This dog is very friendly.
'             Capture 0: This dog is very friendly.
'          Group 1: friendly.
'             Capture 0: This
'             Capture 1: dog
'             Capture 2: is
'             Capture 3: very
'             Capture 4: friendly.
'          Group 2: friendly
'             Capture 0: This
'             Capture 1: dog
'             Capture 2: is
'             Capture 3: very
'             Capture 4: friendly

Das Muster für reguläre Ausdrücke ((\w+)[\s.])+ wird entsprechend der folgenden Tabelle definiert: Beachten Sie, dass in diesem regulären Ausdruck ein Quantifizierer (+) auf den gesamten regulären Ausdruck angewendet wird.

Muster	Beschreibung
`(\w+)`	Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die zweite Erfassungsgruppe.
`[\s.])`	Entspricht einem Leerzeichen oder Punkt (".").
`((\w+)[\s.])`	Entspricht mindestens einem Wortzeichen, gefolgt von einem Leerzeichen oder Punkt ("."). Dies ist die erste Erfassungsgruppe.
`((\w+)[\s.])+`	Entspricht einem oder mehreren Vorkommen eines Wortzeichens oder -zeichens, gefolgt von einem Leerzeichen oder Punkt (".").

In diesem Beispiel besteht die Eingabezeichenfolge aus zwei Sätzen. Wie die Ausgabe zeigt, besteht der erste Satz nur aus einem Wort, sodass das CaptureCollection Objekt über ein einzelnes Capture Objekt verfügt, das dieselbe Erfassung wie das Group Objekt darstellt. Der zweite Satz besteht aus mehreren Wörtern, sodass die Group Objekte nur Informationen über den letzten übereinstimmenen Teilausdruck enthalten. Gruppe 1, die die erste Erfassung darstellt, enthält das letzte Wort im Satz, der einen Abschlusszeitraum aufweist. Gruppe 2, die die zweite Erfassung darstellt, enthält das letzte Wort im Satz. Die Capture Objekte im Objekt der Gruppe CaptureCollection erfassen jedoch jeden Teilausdruck. Die Capture Objekte in der Erfassungssammlung der ersten Erfassungsgruppe enthalten Informationen zu jedem erfassten Wort und Leerzeichen oder Zeitraum. Die Capture Objekte in der Sammlung von Erfassungen der zweiten Erfassungsgruppe enthalten Informationen zu jedem erfassten Wort.

Im folgenden Beispiel wird das Muster für reguläre Ausdrücke verwendet, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$um eine Produktnummer abzugleichen, die aus zwei Teilen besteht, die durch einen Punkt getrennt sind. Beide Teile bestehen aus alphabetischen Zeichen, gefolgt von optionalen Zahlen. Da die erste Eingabezeichenfolge nicht mit dem Muster übereinstimmt, ist String.Emptyder Wert der -Eigenschaft des Value zurückgegebenen System.Text.RegularExpressions.Match Objekts . Wenn das Muster für reguläre Ausdrücke nicht mit einer Erfassungsgruppe übereinstimmen kann, lautet String.Emptyder Wert der -Eigenschaft des Value entsprechenden Group Objekts .

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String pattern = @"^([a-z]+)(\d+)?\.([a-z]+(\d)*)$";
      String[] values = { "AC10", "Za203.CYM", "XYZ.CoA", "ABC.x170" };   
      foreach (var value in values) {
         Match m = Regex.Match(value, pattern, RegexOptions.IgnoreCase);
         if (m.Success) {
            Console.WriteLine("Match: '{0}'", m.Value);
            Console.WriteLine("   Number of Capturing Groups: {0}", 
                              m.Groups.Count);
            for (int gCtr = 0; gCtr < m.Groups.Count; gCtr++) {
               Group group = m.Groups[gCtr];
               Console.WriteLine("      Group {0}: {1}", gCtr, 
                                 group.Value == "" ? "<empty>" : "'" + group.Value + "'");   
               Console.WriteLine("         Number of Captures: {0}", 
                                 group.Captures.Count);
           
               for (int cCtr = 0; cCtr < group.Captures.Count; cCtr++) 
                  Console.WriteLine("            Capture {0}: {1}", 
                                    cCtr, group.Captures[cCtr].Value);
            }
         } 
         else {
            Console.WriteLine("No match for {0}: Match.Value is {1}", 
                              value, m.Value == String.Empty ? "<empty>" : m.Value);
         }
      }
   }
}
// The example displays the following output:
//       No match for AC10: Match.Value is <empty>
//       Match: 'Za203.CYM'
//          Number of Capturing Groups: 5
//             Group 0: 'Za203.CYM'
//                Number of Captures: 1
//                   Capture 0: Za203.CYM
//             Group 1: 'Za'
//                Number of Captures: 1
//                   Capture 0: Za
//             Group 2: '203'
//                Number of Captures: 1
//                   Capture 0: 203
//             Group 3: 'CYM'
//                Number of Captures: 1
//                   Capture 0: CYM
//             Group 4: <empty>
//                Number of Captures: 0
//       Match: 'XYZ.CoA'
//          Number of Capturing Groups: 5
//             Group 0: 'XYZ.CoA'
//                Number of Captures: 1
//                   Capture 0: XYZ.CoA
//             Group 1: 'XYZ'
//                Number of Captures: 1
//                   Capture 0: XYZ
//             Group 2: <empty>
//                Number of Captures: 0
//             Group 3: 'CoA'
//                Number of Captures: 1
//                   Capture 0: CoA
//             Group 4: <empty>
//                Number of Captures: 0
//       Match: 'ABC.x170'
//          Number of Capturing Groups: 5
//             Group 0: 'ABC.x170'
//                Number of Captures: 1
//                   Capture 0: ABC.x170
//             Group 1: 'ABC'
//                Number of Captures: 1
//                   Capture 0: ABC
//             Group 2: <empty>
//                Number of Captures: 0
//             Group 3: 'x170'
//                Number of Captures: 1
//                   Capture 0: x170
//             Group 4: '0'
//                Number of Captures: 3
//                   Capture 0: 1
//                   Capture 1: 7
//                   Capture 2: 0

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^([a-z]+)(\d+)?\.([a-z]+(\d)*)$"
      Dim values() As String = { "AC10", "Za203.CYM", "XYZ.CoA", "ABC.x170" }   
      For Each value In values
         Dim m As Match = Regex.Match(value, pattern, RegexOptions.IgnoreCase)
         If m.Success Then
            Console.WriteLine("Match: '{0}'", m.Value)
            Console.WriteLine("   Number of Capturing Groups: {0}", 
                              m.Groups.Count)
            For gCtr As Integer = 0 To m.Groups.Count - 1
               Dim group As Group = m.Groups(gCtr)
               Console.WriteLine("      Group {0}: {1}", gCtr, 
                                 If(group.Value = "", "<empty>", "'" + group.Value + "'"))   
               Console.WriteLine("         Number of Captures: {0}", 
                                 group.Captures.Count)
           
               For cCtr As Integer = 0 To group.Captures.Count - 1
                  Console.WriteLine("            Capture {0}: {1}", 
                                    cCtr, group.Captures(cCtr).Value)
               Next
            Next
         Else
            Console.WriteLine("No match for {0}: Match.Value is {1}", 
                              value, If(m.Value = String.Empty, "<empty>", m.Value))
         End If
      Next    
   End Sub
End Module
' The example displays the following output:
'       No match for AC10: Match.Value is <empty>
'       Match: 'Za203.CYM'
'          Number of Capturing Groups: 5
'             Group 0: 'Za203.CYM'
'                Number of Captures: 1
'                   Capture 0: Za203.CYM
'             Group 1: 'Za'
'                Number of Captures: 1
'                   Capture 0: Za
'             Group 2: '203'
'                Number of Captures: 1
'                   Capture 0: 203
'             Group 3: 'CYM'
'                Number of Captures: 1
'                   Capture 0: CYM
'             Group 4: <empty>
'                Number of Captures: 0
'       Match: 'XYZ.CoA'
'          Number of Capturing Groups: 5
'             Group 0: 'XYZ.CoA'
'                Number of Captures: 1
'                   Capture 0: XYZ.CoA
'             Group 1: 'XYZ'
'                Number of Captures: 1
'                   Capture 0: XYZ
'             Group 2: <empty>
'                Number of Captures: 0
'             Group 3: 'CoA'
'                Number of Captures: 1
'                   Capture 0: CoA
'             Group 4: <empty>
'                Number of Captures: 0
'       Match: 'ABC.x170'
'          Number of Capturing Groups: 5
'             Group 0: 'ABC.x170'
'                Number of Captures: 1
'                   Capture 0: ABC.x170
'             Group 1: 'ABC'
'                Number of Captures: 1
'                   Capture 0: ABC
'             Group 2: <empty>
'                Number of Captures: 0
'             Group 3: 'x170'
'                Number of Captures: 1
'                   Capture 0: x170
'             Group 4: '0'
'                Number of Captures: 3
'                   Capture 0: 1
'                   Capture 1: 7
'                   Capture 2: 0

Das Muster für reguläre Ausdrücke wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibung
`^`	Beginnt die Suche am Anfang der Zeichenfolge.
`([a-z]+)`	Entspricht mindestens einem Vorkommen eines Zeichens von einem bis z. Da der Engine für reguläre Ausdrücke die RegexOptions.IgnoreCase Option übergeben wird, wird bei diesem Vergleich die Groß-/Kleinschreibung nicht beachtet. Dies ist die erste Erfassungsgruppe.
`(\d+)?`	Entspricht null oder einem Vorkommen einer oder mehrerer Dezimalstellen. Dies ist die zweite Erfassungsgruppe.
`\.`	Übereinstimmung mit einem Literalperiodenzeichen.
`([a-z]+`	Entspricht mindestens einem Vorkommen eines Zeichens von einem bis z. Bei dem Vergleich wird Groß- und Kleinschreibung nicht unterschieden.
`(\d)*`	0 (null) oder mehr Dezimalstellen sollen übereinstimmen. Eine einzelne übereinstimmende Ziffer ist die vierte Erfassungsgruppe.
`([a-z]+(\d)*)`	Übereinstimmung mit einem oder mehreren alphabetischen Zeichen von einem bis z gefolgt von null, einer oder mehreren Dezimalstellen. Dies ist die vierte Erfassungsgruppe.
`$`	Schließen Sie die Übereinstimmung am Ende der Zeichenfolge ab.

Hinweise

Wenn ein Aufruf der Regex.Match - oder Match.NextMatch -Methode keine Übereinstimmung findet, ist String.Emptyder Wert der zurückgegebenen Match.Value Eigenschaft . Wenn die Engine für reguläre Ausdrücke eine Erfassungsgruppe nicht zuordnen kann. Der Wert der zurückgegebenen Group.Value Eigenschaft ist String.Empty. Im zweiten Beispiel finden Sie eine Abbildung.

Gilt für:

Teilen über