CaptureCollection 클래스

정의

단일 캡처링 그룹에서 만든 캡처 집합을 나타냅니다.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
상속
CaptureCollection
특성
구현

예제

다음 예제에서는 비교 합니다 Capture 개체를 CaptureCollection 에서 반환 된 개체를 Group.CapturesMatch.Captures 속성입니다.The following example compares the Capture objects in the CaptureCollection object returned by the Group.Captures and Match.Captures properties. 또한 비교 Group 사용 하 여 개체를 Capture 개체를 CaptureCollection 반환한는 Group.Captures 속성.It also compares Group objects with the Capture objects in the CaptureCollection returned by the Group.Captures property. 이 예제에서는 단일 입력된 문자열에서 일치 항목을 찾으려면 다음 두 개의 정규식을 사용 합니다.The example uses the following two regular expressions to find matches in a single input string:

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

    이 정규식 패턴 뒤에 하나 또는 두 개의 비단어 문자가 공백 또는 문장 부호와 같은 하나 이상의 단어 문자로 구성 된 단어를 식별 합니다.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. 정규식에서 캡처링 그룹을 포함 하지 않습니다.The regular expression does not include any capturing groups. 예제의 출력에 따르면 모두를 Match 개체 및 CaptureCollection 반환한 개체는 Group.CapturesMatch.Captures 속성 동일한 일치 하는 방법에 대 한 정보를 포함 합니다.The 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})+

    이 정규식 패턴은 문장에서 단어를 식별합니다.This regular expression pattern identifies the words in a sentence. 패턴을 하나 또는 두 개의 비단어 문자가 따라오는 단어 문자를 하나 이상으로 이루어진 단일 캡처링 그룹을 정의 합니다.The pattern defines a single capturing group that consists of one or more word characters followed by one or two non-word characters. 정규식 패턴을 사용 하는 + 수량자를이 그룹의 하나를 찾습니다.The regular expression pattern uses the + quantifier to match one or more occurrences of this group. 이 예제의 출력을 보여 줍니다 합니다 Match 개체 및 CaptureCollection 반환한 개체는 Match.Captures 동일한 일치 하는 방법에 대 한 정보를 포함 하는 속성입니다.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. 두 번째 Group 정규식에서 유일한 캡처링 그룹에 해당 하는 개체를 식별 하는 마지막 문자열을 캡처된 반면 합니다 CaptureCollection 첫 번째 캡처링 그룹에 의해 반환 되는 개체 Group.Captures 속성 모두 포함 캡처된 부분 문자열입니다.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.'

설명

컬렉션을 변경할 수 없는 (읽기 전용) 및 공용 생성자가 없습니다.The collection is immutable (read-only) and has no public constructor. 합니다 CaptureCollection 하나 이상의 개체에 포함 되어 있습니다 Capture 개체입니다.The CaptureCollection object contains one or more Capture objects.

인스턴스는 CaptureCollection 클래스 같은 속성으로 반환 됩니다.Instances of the CaptureCollection class are returned by the following properties:

  • Group.Captures 속성The Group.Captures property. 컬렉션의 각 멤버는 캡처링 그룹에 의해 캡처된 부분 문자열을 나타냅니다.Each member of the collection represents a substring captured by a capturing group. 캡처링 그룹에 수량자를 적용 하지 않으면 합니다 CaptureCollection 하나만 포함 Capture 나타내는 동일한 캡처된 부분 문자열을는 Group 개체입니다.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. 캡처링 그룹에 수량자가 적용 하는 경우는 CaptureCollection 하나가 포함 Capture 각 캡처된 부분 문자열 및 Group 캡처된 마지막 부분 문자열에 대 한 정보를 제공 하는 개체입니다.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.

  • Match.Captures 속성The Match.Captures property. 단일 컬렉션을 구성 하는 예제의 경우 Capture 전체적으로 일치 하는 방법에 대 한 정보를 제공 하는 개체입니다.In this case, the collection consists of a single Capture object that provides information about the match as a whole. 즉, 합니다 CaptureCollection 개체와 동일한 정보를 제공 합니다 Match 개체입니다.That is, the CaptureCollection object provides the same information as the Match object.

컬렉션의 멤버를 반복 하려면 언어에서 제공 컬렉션 반복 구조를 사용 해야 합니다 (같은 foreach C# 및 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 Visual Basic의 경우)에 의해 반환 되는 열거자를 검색 하는 대신는 GetEnumerator 메서드.in Visual Basic) instead of retrieving the enumerator that is returned by the GetEnumerator method.

속성

Count

그룹에서 캡처한 부분 문자열의 수를 가져옵니다.Gets the number of substrings captured by the group.

IsReadOnly

컬렉션이 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the collection is read only.

IsSynchronized

해당 컬렉션에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether access to the collection is synchronized (thread-safe).

Item[Int32]

컬렉션의 개별 멤버를 가져옵니다.Gets an individual member of the collection.

SyncRoot

컬렉션에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the collection.

메서드

CopyTo(Array, Int32)

지정된 인덱스에서 시작하여 지정된 배열에 컬렉션의 요소를 모두 복사합니다.Copies all the elements of the collection to the given array beginning at the given index.

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

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetEnumerator()

컬렉션을 반복하는 열거자를 제공합니다.Provides an enumerator that iterates through the collection.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)

명시적 인터페이스 구현

ICollection.CopyTo(Array, Int32)

지정된 인덱스에서 시작하여 지정된 배열에 컬렉션의 요소를 모두 복사합니다.Copies all the elements of the collection to the given array beginning at the given index.

ICollection.IsSynchronized

해당 컬렉션에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether access to the collection is synchronized (thread-safe).

ICollection.SyncRoot

컬렉션에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the collection.

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

확장 메서드

Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

쿼리를 병렬화할 수 있도록 합니다.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerableIQueryable로 변환합니다.Converts an IEnumerable to an IQueryable.

적용 대상

추가 정보