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 classe MatchCollection pour interroger un ensemble d’instances de Match.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 objets System.Text.RegularExpressions.Match.The collection contains zero or more System.Text.RegularExpressions.Match objects. Si la correspondance est réussie, la collection est remplie avec un objet System.Text.RegularExpressions.Match 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 objet System.Text.RegularExpressions.Match, et sa propriété Count 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’une des deux techniques suivantes pour générer l’objet MatchCollection :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’objet MatchCollection est rempli en une seule fois, avec toutes les correspondances résultant d’un appel particulier à la méthode Regex.Matches.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 à la propriété Count 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’objet MatchCollection est rempli en fonction des besoins selon la correspondance.The MatchCollection object is populated as needed on a match-by-match basis. Cela équivaut au moteur d’expression régulière appelant la méthode Regex.Match à plusieurs reprises et à ajouter 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 biais de sa méthode GetEnumerator, ou lorsqu’elle est accessible à l’aide C#de l’instruction foreach (dans) ou de l’instruction For Each...Next (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 (par C# exemple, foreach dans et 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 dans Visual Basic) au lieu de récupérer l’énumérateur retourné par la méthode GetEnumerator.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 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 égal à 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()

Sert 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 en cours.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 à