MatchCollection Classe

Definição

Representa o conjunto de correspondências de sucesso encontrado iterativamente aplicando um padrão de expressão regular à cadeia de caracteres de entrada.Represents the set of successful matches found by iteratively applying a regular expression pattern to the input string.

public ref class MatchCollection : System::Collections::ICollection
[System.Serializable]
public class MatchCollection : System.Collections.ICollection
type MatchCollection = class
    interface ICollection
    interface IEnumerable
Public Class MatchCollection
Implements ICollection
Herança
MatchCollection
Atributos
Implementações

Exemplos

O exemplo a seguir ilustra o uso da MatchCollection classe para interrogar um conjunto de Match instâncias.The following example illustrates the use of the MatchCollection class to interrogate a set of Match instances.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumps over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }
        
    }
    
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

Comentários

A coleção é imutável (somente leitura) e não tem nenhum construtor público.The collection is immutable (read-only) and has no public constructor. O método Regex.Matches retorna um objeto MatchCollection.The Regex.Matches method returns a MatchCollection object.

A coleção contém zero ou mais System.Text.RegularExpressions.Match objetos.The collection contains zero or more System.Text.RegularExpressions.Match objects. Se a correspondência for bem-sucedida, a coleção será populada System.Text.RegularExpressions.Match com um objeto para cada correspondência encontrada na cadeia de caracteres de entrada.If the match is successful, the collection is populated with one System.Text.RegularExpressions.Match object for each match found in the input string. Se a correspondência não for bem-sucedida, a coleção não conterá System.Text.RegularExpressions.Match nenhum objeto e sua Count propriedade será igual a zero.If the match is unsuccessful, the collection contains no System.Text.RegularExpressions.Match objects, and its Count property equals zero.

Ao aplicar um padrão de expressão regular a uma cadeia de caracteres de entrada específica, o mecanismo de expressão regular usa uma das MatchCollection duas técnicas para criar o objeto:When applying a regular expression pattern to a particular input string, the regular expression engine uses either of two techniques to build the MatchCollection object:

  • Avaliação direta.Direct evaluation.

    O MatchCollection objeto é preenchido de uma só vez, com todas as correspondências resultantes de uma Regex.Matches chamada específica para o método.The MatchCollection object is populated all at once, with all matches resulting from a particular call to the Regex.Matches method. Essa técnica é usada quando a propriedade da Count coleção é acessada.This technique is used when the collection's Count property is accessed. Normalmente, é o método mais caro de popular a coleção e envolve um maior impacto no desempenho.It typically is the more expensive method of populating the collection and entails a greater performance hit.

  • Avaliação lenta.Lazy evaluation.

    O MatchCollection objeto é populado conforme necessário em uma base correspondente.The MatchCollection object is populated as needed on a match-by-match basis. É equivalente ao mecanismo de expressão regular chamando o Regex.Match método repetidamente e adicionando cada correspondência à coleção.It is equivalent to the regular expression engine calling the Regex.Match method repeatedly and adding each match to the collection. Essa técnica é usada quando a coleção é acessada GetEnumerator por meio de seu método ou quando é acessada usando C#a For Each foreach instrução (in) ou... Next instrução (em Visual Basic).This technique is used when the collection is accessed through its GetEnumerator method, or when it is accessed using the foreach statement (in C#) or the For Each...Next statement (in Visual Basic).

Para iterar pelos membros da coleção, você deve usar a construção de iteração de coleção fornecida pelo seu idioma ( foreach como C# no For Eache no...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 em Visual Basic) em vez de recuperar o enumerador que é retornado pelo GetEnumerator método.in Visual Basic) instead of retrieving the enumerator that is returned by the GetEnumerator method.

Propriedades

Count

Obtém o número de correspondências.Gets the number of matches.

IsReadOnly

Obtém um valor que indica se a coleção é somente leitura.Gets a value that indicates whether the collection is read only.

IsSynchronized

Obtém um valor que indica se o acesso à coleção é sincronizado (thread-safe).Gets a value indicating whether access to the collection is synchronized (thread-safe).

Item[Int32]

Obtém um membro individual da coleção.Gets an individual member of the collection.

SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso à coleção.Gets an object that can be used to synchronize access to the collection.

Métodos

CopyTo(Array, Int32)

Copia todos os elementos da coleção para a matriz especificada, começando pelo índice especificado.Copies all the elements of the collection to the given array starting at the given index.

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetEnumerator()

Fornece um enumerador iterado por meio da coleção.Provides an enumerator that iterates through the collection.

GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)

Implantações explícitas de interface

ICollection.CopyTo(Array, Int32)

Copia todos os elementos da coleção para a matriz especificada, começando no índice especificado.Copies all the elements of the collection to the specified array starting at the specified index.

ICollection.IsSynchronized

Obtém um valor que indica se o acesso à coleção é sincronizado (thread-safe).Gets a value that indicates whether access to the collection is synchronized (thread-safe).

ICollection.SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso à coleção.Gets an object that can be used to synchronize access to the collection.

ICollection<Match>.Add(Match)
ICollection<Match>.Clear()
ICollection<Match>.Contains(Match)
ICollection<Match>.Remove(Match)
IEnumerable<Match>.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<Match>.IndexOf(Match)
IList<Match>.Insert(Int32, Match)
IList<Match>.Item[Int32]
IList<Match>.RemoveAt(Int32)

Métodos de Extensão

Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Aplica-se a