CaptureCollection CaptureCollection CaptureCollection CaptureCollection Class

Definition

Stellt den Satz von Erfassungen einer einzelnen Erfassungsgruppe dar.Represents the set of captures made by a single capturing group.

public ref class CaptureCollection : System::Collections::ICollection
[System.Serializable]
public class CaptureCollection : System.Collections.ICollection
type CaptureCollection = class
    interface ICollection
    interface IEnumerable
Public Class CaptureCollection
Implements ICollection
Vererbung
CaptureCollectionCaptureCollectionCaptureCollectionCaptureCollection
Attribute
Implementiert

Beispiele

Im folgenden Beispiel werden die Capture -Objekte in CaptureCollection dem-Objekt verglichen Group.Captures , Match.Captures das von den Eigenschaften und zurückgegeben wird.The following example compares the Capture objects in the CaptureCollection object returned by the Group.Captures and Match.Captures properties. Außerdem werden- Group Objekte mit den Capture Objekten in der CaptureCollection verglichen, die Group.Captures von der-Eigenschaft zurückgegeben werden.It also compares Group objects with the Capture objects in the CaptureCollection returned by the Group.Captures property. In diesem Beispiel werden die folgenden zwei regulären Ausdrücke verwendet, um Übereinstimmungen in einer einzelnen Eingabe Zeichenfolge zu suchen:The example uses the following two regular expressions to find matches in a single input string:

  • \b\w+\W{1,2}

    Dieses Muster für reguläre Ausdrücke identifiziert ein Wort, das aus einem oder mehreren Wort Zeichen besteht, gefolgt von einem oder zwei nicht-Wort Zeichen (z. b. Leerzeichen oder Interpunktions Zeichen).This regular expression pattern identifies a word that consists of one or more word characters, followed by either one or two non-word characters such as white space or punctuation. Der reguläre Ausdruck enthält keine Erfassungs Gruppen.The regular expression does not include any capturing groups. Die Ausgabe aus dem Beispiel zeigt, dass sowohl Match das-Objekt als auch die- Group.Captures Objekte Match.Captures , die von der-Eigenschaft und der CaptureCollection -Eigenschaft zurückgegeben werden, Informationen zur gleichenThe output from the example shows that both the Match object and the CaptureCollection objects returned by the Group.Captures and Match.Captures properties contain information about the same match.

  • (\b\w+\W{1,2})+

    Dieses Muster für reguläre Ausdrücke identifiziert die Wörter in einem Satz.This regular expression pattern identifies the words in a sentence. Das Muster definiert eine einzelne Erfassungs Gruppe, die aus einem oder mehreren Wort Zeichen gefolgt von einem oder zwei nicht-Wort Zeichen besteht.The pattern defines a single capturing group that consists of one or more word characters followed by one or two non-word characters. Das Muster für reguläre Ausdrücke verwendet + den-Quantifizierer, um ein oder mehrere Vorkommen dieser Gruppe abzugleichen.The regular expression pattern uses the + quantifier to match one or more occurrences of this group. Die Ausgabe dieses Beispiels zeigt, dass das Match -Objekt und CaptureCollection das-Objekt, Match.Captures das von der-Eigenschaft zurückgegeben wird, Informationen zur gleichen Übereinstimmung enthalten.The output from this example shows that the Match object and the CaptureCollection object returned by the Match.Captures property contain information about the same match. Das zweite Group -Objekt, das der einzigen Erfassungs Gruppe im regulären Ausdruck entspricht, identifiziert nur die zuletzt erfasste Zeichenfolge, CaptureCollection während das Objekt, das von Group.Captures der ersten Erfassungs Gruppe zurückgegeben wird, alle enthält. erfasste Teil Zeichenfolgen.The second Group object, which corresponds to the only capturing group in the regular expression, identifies only the last captured string, whereas the CaptureCollection object returned by the first capturing group's Group.Captures property includes all captured substrings.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern;  
      string input = "The young, hairy, and tall dog slowly walked across the yard.";
      Match match;

      // Match a word with a pattern that has no capturing groups.
      pattern = @"\b\w+\W{1,2}";
      match = Regex.Match(input, pattern);
      Console.WriteLine("Pattern: " + pattern);
      Console.WriteLine("Match: " + match.Value);
      Console.WriteLine("  Match.Captures: {0}", match.Captures.Count);
      for (int ctr = 0; ctr < match.Captures.Count; ctr++)
         Console.WriteLine("    {0}: '{1}'", ctr, match.Captures[ctr].Value);
      Console.WriteLine("  Match.Groups: {0}", match.Groups.Count);
      for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
      {
         Console.WriteLine("    Group {0}: '{1}'", 
                           groupCtr, match.Groups[groupCtr].Value);
         Console.WriteLine("    Group({0}).Captures: {1}", 
                           groupCtr, match.Groups[groupCtr].Captures.Count);
         for (int captureCtr = 0; captureCtr < match.Groups[groupCtr].Captures.Count; captureCtr++)
            Console.WriteLine("      Capture {0}: '{1}'", 
                              captureCtr, 
                              match.Groups[groupCtr].Captures[captureCtr].Value);
      }
      Console.WriteLine("-----\n");

      // Match a sentence with a pattern that has a quantifier that 
      // applies to the entire group.
      pattern = @"(\b\w+\W{1,2})+";
      match = Regex.Match(input, pattern);
      Console.WriteLine("Pattern: " + pattern);
      Console.WriteLine("Match: " + match.Value);
      Console.WriteLine("  Match.Captures: {0}", match.Captures.Count);
      for (int ctr = 0; ctr < match.Captures.Count; ctr++)
         Console.WriteLine("    {0}: '{1}'", ctr, match.Captures[ctr].Value);
      
      Console.WriteLine("  Match.Groups: {0}", match.Groups.Count);
      for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
      {
         Console.WriteLine("    Group {0}: '{1}'", groupCtr, match.Groups[groupCtr].Value);
         Console.WriteLine("    Group({0}).Captures: {1}", 
                           groupCtr, match.Groups[groupCtr].Captures.Count);
         for (int captureCtr = 0; captureCtr < match.Groups[groupCtr].Captures.Count; captureCtr++)
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, match.Groups[groupCtr].Captures[captureCtr].Value);
      }
   }
}
// The example displays the following output:
//    Pattern: \b\w+\W{1,2}
//    Match: The
//      Match.Captures: 1
//        0: 'The '
//      Match.Groups: 1
//        Group 0: 'The '
//        Group(0).Captures: 1
//          Capture 0: 'The '
//    -----
//    
//    Pattern: (\b\w+\W{1,2})+
//    Match: The young, hairy, and tall dog slowly walked across the yard.
//      Match.Captures: 1
//        0: 'The young, hairy, and tall dog slowly walked across the yard.'
//      Match.Groups: 2
//        Group 0: 'The young, hairy, and tall dog slowly walked across the yard.'
//        Group(0).Captures: 1
//          Capture 0: 'The young, hairy, and tall dog slowly walked across the yard.'
//        Group 1: 'yard.'
//        Group(1).Captures: 11
//          Capture 0: 'The '
//          Capture 1: 'young, '
//          Capture 2: 'hairy, '
//          Capture 3: 'and '
//          Capture 4: 'tall '
//          Capture 5: 'dog '
//          Capture 6: 'slowly '
//          Capture 7: 'walked '
//          Capture 8: 'across '
//          Capture 9: 'the '
//          Capture 10: 'yard.'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String  
      Dim input As String = "The young, hairy, and tall dog slowly walked across the yard."
      Dim match As Match

      ' Match a word with a pattern that has no capturing groups.
      pattern = "\b\w+\W{1,2}"
      match = Regex.Match(input, pattern)
      Console.WriteLine("Pattern: " + pattern)
      Console.WriteLine("Match: " + match.Value)
      Console.WriteLine("  Match.Captures: {0}", match.Captures.Count)
      For ctr As Integer = 0 To match.Captures.Count - 1
         Console.WriteLine("    {0}: '{1}'", ctr, match.Captures(ctr).Value)
      Next
      Console.WriteLine("  Match.Groups: {0}", match.Groups.Count)
      For groupCtr As Integer = 0 To match.Groups.Count - 1
         Console.WriteLine("    Group {0}: '{1}'", groupCtr, match.Groups(groupCtr).Value)
         Console.WriteLine("    Group({0}).Captures: {1}", _
                           groupCtr, match.Groups(groupCtr).Captures.Count)
         For captureCtr As Integer = 0 To match.Groups(groupCtr).Captures.Count - 1
            Console.WriteLine("      Capture {0}: '{1}'", _
                              captureCtr, _
                              match.Groups(groupCtr).Captures(captureCtr).Value)
         Next
      Next
      Console.WriteLine("-----")
      Console.WriteLine()

      ' Match a sentence with a pattern that has a quantifier that 
      ' applies to the entire group.
      pattern = "(\b\w+\W{1,2})+"
      match = Regex.Match(input, pattern)
      Console.WriteLine("Pattern: " + pattern)
      Console.WriteLine("Match: " + match.Value)
      Console.WriteLine("  Match.Captures: {0}", match.Captures.Count)
      For ctr As Integer = 0 To match.Captures.Count - 1
         Console.WriteLine("    {0}: '{1}'", ctr, match.Captures(ctr).Value)
      Next
      Console.WriteLine("  Match.Groups: {0}", match.Groups.Count)
      For groupCtr As Integer = 0 To match.Groups.Count - 1
         Console.WriteLine("    Group {0}: '{1}'", groupCtr, match.Groups(groupCtr).Value)
         Console.WriteLine("    Group({0}).Captures: {1}", _
                           groupCtr, match.Groups(groupCtr).Captures.Count)
         For captureCtr As Integer = 0 To match.Groups(groupCtr).Captures.Count - 1
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, match.Groups(groupCtr).Captures(captureCtr).Value)
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'    Pattern: \b\w+\W{1,2}
'    Match: The
'      Match.Captures: 1
'        0: 'The '
'      Match.Groups: 1
'        Group 0: 'The '
'        Group(0).Captures: 1
'          Capture 0: 'The '
'    -----
'    
'    Pattern: (\b\w+\W{1,2})+
'    Match: The young, hairy, and tall dog slowly walked across the yard.
'      Match.Captures: 1
'        0: 'The young, hairy, and tall dog slowly walked across the yard.'
'      Match.Groups: 2
'        Group 0: 'The young, hairy, and tall dog slowly walked across the yard.'
'        Group(0).Captures: 1
'          Capture 0: 'The young, hairy, and tall dog slowly walked across the yard.'
'        Group 1: 'yard.'
'        Group(1).Captures: 11
'          Capture 0: 'The '
'          Capture 1: 'young, '
'          Capture 2: 'hairy, '
'          Capture 3: 'and '
'          Capture 4: 'tall '
'          Capture 5: 'dog '
'          Capture 6: 'slowly '
'          Capture 7: 'walked '
'          Capture 8: 'across '
'          Capture 9: 'the '
'          Capture 10: 'yard.'

Hinweise

Die Auflistung ist unveränderlich (schreibgeschützt) und verfügt über keinen öffentlichen Konstruktor.The collection is immutable (read-only) and has no public constructor. Das CaptureCollection -Objekt enthält ein oder Capture mehrere-Objekte.The CaptureCollection object contains one or more Capture objects.

Instanzen der CaptureCollection -Klasse werden von den folgenden Eigenschaften zurückgegeben:Instances of the CaptureCollection class are returned by the following properties:

  • Die Group.Captures-EigenschaftThe Group.Captures property. Jeder Member der Auflistung stellt eine Teil Zeichenfolge dar, die von einer Erfassungs Gruppe erfasst wird.Each member of the collection represents a substring captured by a capturing group. Wenn ein Quantifizierer nicht für eine Erfassungs Gruppe übernommen wird CaptureCollection , enthält das Capture ein einzelnes-Objekt, das die gleiche erfasste Group Teil Zeichenfolge wie das-Objekt darstellt.If a quantifier is not applied to a capturing group, the CaptureCollection includes a single Capture object that represents the same captured substring as the Group object. Wenn ein Quantifizierer auf eine Erfassungs Gruppe angewendet wird CaptureCollection , enthält Capture das ein-Objekt für jede erfasste Teil Group Zeichenfolge, und das-Objekt stellt nur Informationen zur letzten erfassten Teil Zeichenfolge bereit.If a quantifier is applied to a capturing group, the CaptureCollection includes one Capture object for each captured substring, and the Group object provides information only about the last captured substring.

  • Die Match.Captures-EigenschaftThe Match.Captures property. In diesem Fall besteht die-Auflistung aus einem einzelnen Capture -Objekt, das Informationen über die Übereinstimmung als Ganzes bereitstellt.In this case, the collection consists of a single Capture object that provides information about the match as a whole. Das heißt, CaptureCollection dass das-Objekt die gleichen Informationen wie Match das-Objekt bereitstellt.That is, the CaptureCollection object provides the same information as the Match object.

Um die Elemente der Auflistung zu durchlaufen, sollten Sie das von Ihrer Sprache bereitgestellten Auflistung Iteration-Konstrukt verwenden (z. B. foreach in C# geschrieben und For Each...NextTo iterate through the members of the collection, you should use the collection iteration construct provided by your language (such as foreach in C# and For EachNext in Visual Basic) anstatt den Enumerator abzurufen, der von der GetEnumerator -Methode zurückgegeben wird.in Visual Basic) instead of retrieving the enumerator that is returned by the GetEnumerator method.

Eigenschaften

Count Count Count Count

Ruft die Anzahl der Teilzeichenfolgen ab, die von der Gruppe erfasst wurden.Gets the number of substrings captured by the group.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ruft einen Wert ab, der angibt, ob die Auflistung schreibgeschützt ist.Gets a value that indicates whether the collection is read only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Auflistung synchronisiert (threadsicher) ist.Gets a value that indicates whether access to the collection is synchronized (thread-safe).

Item[Int32] Item[Int32] Item[Int32] Item[Int32]

Ruft einen einzelnen Member der Auflistung ab.Gets an individual member of the collection.

SyncRoot SyncRoot SyncRoot SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf die Auflistung synchronisiert werden kann.Gets an object that can be used to synchronize access to the collection.

Methoden

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Kopiert alle Elemente der Auflistung ab dem angegebenen Index in das angegebene Array.Copies all the elements of the collection to the given array beginning at the given index.

CopyTo(Capture[], Int32) CopyTo(Capture[], Int32) CopyTo(Capture[], Int32) CopyTo(Capture[], Int32)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Stellt einen Enumerator bereit, der die Auflistung durchläuft.Provides an enumerator that iterates through the collection.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32)

Kopiert alle Elemente der Auflistung ab dem angegebenen Index in das angegebene Array.Copies all the elements of the collection to the given array beginning at the given index.

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Auflistung synchronisiert (threadsicher) ist.Gets a value that indicates whether access to the collection is synchronized (thread-safe).

ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf die Auflistung synchronisiert werden kann.Gets an object that can be used to synchronize access to the collection.

ICollection<Capture>.Add(Capture) ICollection<Capture>.Add(Capture) ICollection<Capture>.Add(Capture) ICollection<Capture>.Add(Capture)
ICollection<Capture>.Clear() ICollection<Capture>.Clear() ICollection<Capture>.Clear() ICollection<Capture>.Clear()
ICollection<Capture>.Contains(Capture) ICollection<Capture>.Contains(Capture) ICollection<Capture>.Contains(Capture) ICollection<Capture>.Contains(Capture)
ICollection<Capture>.Remove(Capture) ICollection<Capture>.Remove(Capture) ICollection<Capture>.Remove(Capture) ICollection<Capture>.Remove(Capture)
IEnumerable<Capture>.GetEnumerator() IEnumerable<Capture>.GetEnumerator() IEnumerable<Capture>.GetEnumerator() IEnumerable<Capture>.GetEnumerator()
IList.Add(Object) IList.Add(Object) IList.Add(Object) IList.Add(Object)
IList.Clear() IList.Clear() IList.Clear() IList.Clear()
IList.Contains(Object) IList.Contains(Object) IList.Contains(Object) IList.Contains(Object)
IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object)
IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object)
IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize
IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] IList.Item[Int32]
IList.Remove(Object) IList.Remove(Object) IList.Remove(Object) IList.Remove(Object)
IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32)
IList<Capture>.IndexOf(Capture) IList<Capture>.IndexOf(Capture) IList<Capture>.IndexOf(Capture) IList<Capture>.IndexOf(Capture)
IList<Capture>.Insert(Int32, Capture) IList<Capture>.Insert(Int32, Capture) IList<Capture>.Insert(Int32, Capture) IList<Capture>.Insert(Int32, Capture)
IList<Capture>.Item[Int32] IList<Capture>.Item[Int32] IList<Capture>.Item[Int32] IList<Capture>.Item[Int32]
IList<Capture>.RemoveAt(Int32) IList<Capture>.RemoveAt(Int32) IList<Capture>.RemoveAt(Int32) IList<Capture>.RemoveAt(Int32)

Erweiterungsmethoden

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

Gilt für:

Siehe auch