Capture.Value Proprietà

  • Riferimento

Definizione

Spazio dei nomi:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Assembly:
netstandard.dll
Source:
Capture.cs
Source:
Capture.cs
Source:
Capture.cs

Ottiene la sottostringa acquisita dalla stringa di input.

public:
 property System::String ^ Value { System::String ^ get(); };
public string Value { get; }
member this.Value : string
Public ReadOnly Property Value As String

Valore della proprietà

String

Sottostringa acquisita dalla corrispondenza.

Esempio

Nell'esempio seguente viene definita un'espressione regolare che corrisponde a frasi che non contengono punteggiatura, ad eccezione di un punto ("."). La Match.Value proprietà visualizza la stringa di risultato, costituita da una frase corrispondente, per ogni corrispondenza. La Group.Value proprietà visualizza la stringa di risultato per ogni gruppo di acquisizione, costituita dall'ultima stringa acquisita da tale gruppo di acquisizione. La Capture.Value proprietà visualizza la stringa di risultato per ogni acquisizione.

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

Il criterio di ricerca di espressioni regolari ((\w+)[\s.])+ è definito nel modo illustrato nella tabella seguente. Si noti che in questa espressione regolare viene applicato un quantificatore (+) all'intera espressione regolare.

Modello Descrizione
(\w+) Trova la corrispondenza di uno o più caratteri alfanumerici. Equivale al secondo gruppo di acquisizione.
[\s.]) Trova la corrispondenza con uno spazio vuoto o un punto (".").
((\w+)[\s.]) Trova la corrispondenza con uno o più caratteri di parola seguiti da uno spazio vuoto o da un punto ("."). Equivale al primo gruppo di acquisizione.
((\w+)[\s.])+ Trova la corrispondenza con una o più occorrenze di un carattere o di caratteri di una parola seguita da uno spazio vuoto o un punto (".").

In questo esempio la stringa di input è costituita da due frasi. Come illustrato nell'output, la prima frase è costituita da una sola parola, quindi l'oggetto CaptureCollection ha un singolo Capture oggetto che rappresenta la stessa acquisizione dell'oggetto Group . La seconda frase è costituita da più parole, quindi gli Group oggetti contengono solo informazioni sull'ultima sottoespressione corrispondente. Il gruppo 1, che rappresenta la prima acquisizione, contiene l'ultima parola nella frase con un punto di chiusura. Il gruppo 2, che rappresenta la seconda acquisizione, contiene l'ultima parola nella frase. Tuttavia, gli Capture oggetti nell'oggetto del CaptureCollection gruppo acquisiscono ogni corrispondenza di sottoespressione. Gli Capture oggetti nella prima raccolta di acquisizioni del gruppo di acquisizione contengono informazioni su ogni parola acquisita e spazio vuoto o punto. Gli Capture oggetti nella raccolta di acquisizioni del secondo gruppo di acquisizioni contengono informazioni su ogni parola acquisita.

Nell'esempio seguente viene usato un criterio di espressione regolare, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$, per trovare la corrispondenza con un numero di prodotto costituito da due parti separate da un punto. Entrambe le parti sono costituite da caratteri alfabetici seguiti da numeri facoltativi. Poiché la prima stringa di input non corrisponde al criterio, il valore della proprietà dell'oggetto Value restituito System.Text.RegularExpressions.Match è String.Empty. Analogamente, quando il criterio di espressione regolare non è in grado di corrispondere a un gruppo di acquisizione, il valore della proprietà dell'oggetto Value corrispondente Group è String.Empty.

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

Il modello di espressione regolare è definito come illustrato nella tabella seguente:

Modello Descrizione
^ Inizia la ricerca della corrispondenza all'inizio della stringa.
([a-z]+) Trova la corrispondenza di una o più occorrenze di qualsiasi carattere da a z. Poiché il motore delle espressioni regolari viene passata l'opzione RegexOptions.IgnoreCase , questo confronto non fa distinzione tra maiuscole e minuscole. Equivale al primo gruppo di acquisizione.
(\d+)? Trova la corrispondenza con zero o una occorrenza di una o più cifre decimali. Equivale al secondo gruppo di acquisizione.
\. Trova la corrispondenza con un carattere punto letterale.
([a-z]+ Trova la corrispondenza di una o più occorrenze di qualsiasi carattere da a z. Il confronto non fa distinzione tra maiuscole e minuscole.
(\d)* Ricerca la corrispondenza di zero o di più cifre decimali. Una singola cifra corrispondente è il quarto gruppo di acquisizione.
([a-z]+(\d)*) Trova la corrispondenza con uno o più caratteri alfabetici da a z seguiti da zero, uno o più cifre decimali. Questo è il quarto gruppo di acquisizione.
$ Concludere la corrispondenza alla fine della stringa.

Commenti

Se una chiamata al metodo o Match.NextMatch non riesce a Regex.Match trovare una corrispondenza, il valore della proprietà restituita Match.Value è String.Empty. Se il motore delle espressioni regolari non è in grado di trovare la corrispondenza con un gruppo di acquisizione. il valore della proprietà restituita Group.Value è String.Empty. Vedere il secondo esempio per un'illustrazione.

Si applica a