MatchCollection Classe

Définition

Représente l'ensemble des correspondances exactes trouvées en appliquant de manière itérative une expression régulière à la chaîne d'entrée.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
Héritage
MatchCollection
Attributs
Implémente

Exemples

L’exemple suivant illustre l’utilisation de la MatchCollection classe pour interroger un jeu d' Match instances.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

Remarques

La collection est immuable (en lecture seule) et n’a pas de constructeur public.The collection is immutable (read-only) and has no public constructor. La méthode Regex.Matches retourne un objet MatchCollection.The Regex.Matches method returns a MatchCollection object.

La collection contient zéro ou plusieurs System.Text.RegularExpressions.Match objets.The collection contains zero or more System.Text.RegularExpressions.Match objects. Si la correspondance est réussie, la collection est remplie avec un System.Text.RegularExpressions.Match objet pour chaque correspondance trouvée dans la chaîne d’entrée.If the match is successful, the collection is populated with one System.Text.RegularExpressions.Match object for each match found in the input string. Si la correspondance échoue, la collection ne contient aucun System.Text.RegularExpressions.Match objet et sa Count propriété est égale à zéro.If the match is unsuccessful, the collection contains no System.Text.RegularExpressions.Match objects, and its Count property equals zero.

Lors de l’application d’un modèle d’expression régulière à une chaîne d’entrée particulière, le moteur d’expression régulière utilise l' MatchCollection une des deux techniques suivantes pour générer l’objet: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:

  • Évaluation directe.Direct evaluation.

    L' MatchCollection objet est rempli en une seule fois, avec toutes les correspondances résultant d’un appel Regex.Matches particulier à la méthode.The MatchCollection object is populated all at once, with all matches resulting from a particular call to the Regex.Matches method. Cette technique est utilisée lors de l’accès Count à la propriété de la collection.This technique is used when the collection's Count property is accessed. Il s’agit généralement de la méthode la plus coûteuse pour le remplissage de la collection et entraîne un gain de performances supérieur.It typically is the more expensive method of populating the collection and entails a greater performance hit.

  • Évaluation différée.Lazy evaluation.

    L' MatchCollection objet est rempli en fonction des besoins sur une base correspondance-par-correspondance.The MatchCollection object is populated as needed on a match-by-match basis. Elle est équivalente au moteur d’expression régulière appelant Regex.Match la méthode à plusieurs reprises et à l’ajout de chaque correspondance à la collection.It is equivalent to the regular expression engine calling the Regex.Match method repeatedly and adding each match to the collection. Cette technique est utilisée lorsque la collection est accessible par le GetEnumerator biais de sa méthode, ou lorsqu’elle est foreach accessible à l' C#aide de l' For Eachinstruction (dans) ou de... Next instruction (dans 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).

Pour itérer au sein des membres de la collection, vous devez utiliser la construction d’itération de collection fournie par votre langage foreach ( C# par For Eachexemple, dans et...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 dans Visual Basic) au lieu de récupérer l’énumérateur retourné par la GetEnumerator méthode.in Visual Basic) instead of retrieving the enumerator that is returned by the GetEnumerator method.

Propriétés

Count

Obtient le nombre de correspondances.Gets the number of matches.

IsReadOnly

Obtient une valeur qui indique si la collection est en lecture seule.Gets a value that indicates whether the collection is read only.

IsSynchronized

Obtient une valeur indiquant si l'accès à la collection est synchronisé (thread-safe).Gets a value indicating whether access to the collection is synchronized (thread-safe).

Item[Int32]

Obtient un membre individuel de la collection.Gets an individual member of the collection.

SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l’accès à la collection.Gets an object that can be used to synchronize access to the collection.

Méthodes

CopyTo(Array, Int32)

Copie tous les éléments de la collection dans le tableau donné en commençant à l'index spécifié.Copies all the elements of the collection to the given array starting at the given index.

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

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetEnumerator()

Fournit un énumérateur qui itère au sein de la collection.Provides an enumerator that iterates through the collection.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

ICollection.CopyTo(Array, Int32)

Copie tous les éléments de la collection au niveau de l'index spécifié dans le tableau spécifié.Copies all the elements of the collection to the specified array starting at the specified index.

ICollection.IsSynchronized

Obtient une valeur qui indique si l’accès à la collection est synchronisé (thread-safe).Gets a value that indicates whether access to the collection is synchronized (thread-safe).

ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l’accès à la collection.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éthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à