Capture.Value Proprietà
Definizione
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.
Ottiene la sottostringa acquisita dalla stringa di input.
public:
property System::String ^ Value { System::String ^ get(); };public string Value { get; }member this.Value : stringPublic ReadOnly Property Value As StringValore della proprietà
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.
