Capture Classe

Riferimento

Definizione

Spazio dei nomi:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

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.

Rappresenta i risultati di una singola acquisizione di sottoespressione riuscita.

public ref class Capture

public class Capture

[System.Serializable]
public class Capture

type Capture = class

[<System.Serializable>]
type Capture = class

Public Class Capture

Ereditarietà: Object
Capture

Derivato: System.Text.RegularExpressions.Group

Attributi: SerializableAttribute

Esempio

Nell'esempio seguente viene definita un'espressione regolare che corrisponde a frasi che non contengono punteggiatura, ad eccezione di un punto (".").

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.

Commenti

Un Capture oggetto non è modificabile e non dispone di un costruttore pubblico. Le istanze vengono restituite tramite l'oggetto CaptureCollection , restituito dalle Match.Captures proprietà e Group.Captures . Tuttavia, la Match.Captures proprietà fornisce informazioni sulla stessa corrispondenza dell'oggetto Match .

Se non si applica un quantificatore a un gruppo di acquisizione, la Group.Captures proprietà restituisce un CaptureCollection oggetto con un singolo Capture oggetto che fornisce informazioni sulla stessa acquisizione dell'oggetto Group . Se si applica un quantificatore a un gruppo di acquisizione, le Group.Indexproprietà , Group.Lengthe Group.Value forniscono informazioni solo sull'ultimo gruppo acquisito, mentre gli oggetti nell'oggetto Capture CaptureCollection forniscono informazioni su tutte le acquisizioni di sottoespressione. Nell'esempio viene illustrata una situazione di questo tipo.

Proprietà

Index	Posizione nella stringa originale in cui si trova il primo carattere della sottostringa acquisita.
Length	Ottiene la lunghezza della sottostringa acquisita.
Value	Ottiene la sottostringa acquisita dalla stringa di input.
ValueSpan	Ottiene l'intervallo acquisito dalla stringa di input.

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Recupera la sottostringa acquisita dalla stringa di input chiamando la proprietà Value.

Si applica a

Vedi anche

CaptureCollection

Condividi tramite