MatchCollection Classe

Definizione

Rappresenta il gruppo di corrispondenze corrette individuate applicando in modo iterativo un modello di espressione regolare alla stringa di input.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
Ereditarietà
MatchCollection
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato l'utilizzo della MatchCollection classe per interrogare un set di istanze di. MatchThe 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

Commenti

La raccolta non è modificabile (sola lettura) e non dispone di un costruttore pubblico.The collection is immutable (read-only) and has no public constructor. Il metodo Regex.Matches restituisce un oggetto MatchCollection.The Regex.Matches method returns a MatchCollection object.

La raccolta contiene zero o più System.Text.RegularExpressions.Match oggetti.The collection contains zero or more System.Text.RegularExpressions.Match objects. Se la corrispondenza ha esito positivo, la raccolta viene popolata con un System.Text.RegularExpressions.Match oggetto per ogni corrispondenza trovata nella stringa di input.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 la corrispondenza ha esito negativo, la raccolta non System.Text.RegularExpressions.Match contiene oggetti e la relativa Count proprietà è uguale a zero.If the match is unsuccessful, the collection contains no System.Text.RegularExpressions.Match objects, and its Count property equals zero.

Quando si applica un modello di espressione regolare a una determinata stringa di input, il motore delle espressioni regolari usa una delle due MatchCollection tecniche per compilare l'oggetto: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:

  • Valutazione diretta.Direct evaluation.

    L' MatchCollection oggetto viene popolato in una sola volta, con tutte le corrispondenze derivanti Regex.Matches da una particolare chiamata al metodo.The MatchCollection object is populated all at once, with all matches resulting from a particular call to the Regex.Matches method. Questa tecnica viene utilizzata quando si accede alla Count proprietà della raccolta.This technique is used when the collection's Count property is accessed. Si tratta in genere del metodo più costoso per popolare la raccolta e comporta un aumento delle prestazioni.It typically is the more expensive method of populating the collection and entails a greater performance hit.

  • Valutazione lazy.Lazy evaluation.

    L' MatchCollection oggetto viene popolato in base alle esigenze, a seconda della corrispondenza.The MatchCollection object is populated as needed on a match-by-match basis. Equivale al motore delle espressioni regolari che chiama ripetutamente Regex.Match il metodo e aggiunge ogni corrispondenza alla raccolta.It is equivalent to the regular expression engine calling the Regex.Match method repeatedly and adding each match to the collection. Questa tecnica viene utilizzata quando si accede alla raccolta tramite il GetEnumerator relativo metodo o quando si accede utilizzando l' foreach istruzione C# For Each(in) o... Next (in 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).

Per scorrere i membri della raccolta, è necessario utilizzare il costrutto di iterazione della raccolta fornito dal linguaggio (ad foreach esempio C# in For Eache...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) invece di recuperare l'enumeratore restituito dal GetEnumerator metodo.in Visual Basic) instead of retrieving the enumerator that is returned by the GetEnumerator method.

Proprietà

Count

Ottiene il numero di corrispondenze.Gets the number of matches.

IsReadOnly

Ottiene un valore che indica se la raccolta è di sola lettura.Gets a value that indicates whether the collection is read only.

IsSynchronized

Ottiene un valore che indica se l'accesso alla raccolta è sincronizzato (thread-safe).Gets a value indicating whether access to the collection is synchronized (thread-safe).

Item[Int32]

Ottiene un singolo membro della raccolta.Gets an individual member of the collection.

SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso alla raccolta.Gets an object that can be used to synchronize access to the collection.

Metodi

CopyTo(Array, Int32)

Copia tutti gli elementi della raccolta nella matrice indicata a partire dall'indice specificato.Copies all the elements of the collection to the given array starting at the given index.

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

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetEnumerator()

Fornisce un enumeratore che scorre la raccolta.Provides an enumerator that iterates through the collection.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

ICollection.CopyTo(Array, Int32)

Copia gli elementi della raccolta nella matrice specificata, a partire dall'indice specificato.Copies all the elements of the collection to the specified array starting at the specified index.

ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso alla raccolta è sincronizzato (thread-safe).Gets a value that indicates whether access to the collection is synchronized (thread-safe).

ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso alla raccolta.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)

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a