Regex.Matches Méthode

Définition

Recherche dans une chaîne d'entrée toutes les occurrences d'une expression régulière et retourne toutes les correspondances.

Surcharges

Matches(String, String, RegexOptions, TimeSpan)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifiée, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.

Matches(String, String, RegexOptions)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifique, en utilisant les options de correspondance spécifiées.

Matches(String, Int32)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière, en commençant à la position de démarrage spécifiée dans la chaîne.

Matches(String)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière.

Matches(String, String)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifiée.

Matches(String, String, RegexOptions, TimeSpan)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifiée, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Matches : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As MatchCollection

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison de bits de valeurs d'énumération qui spécifient des options pour la correspondance.

matchTimeout
TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.

Retours

MatchCollection

Collection des objets Match trouvés par la recherche. Si aucune correspondance n'est trouvée, la méthode retourne un objet de collection vide.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

input ou pattern est null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

  • ou - matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.

Exemples

L’exemple suivant appelle la méthode pour effectuer une comparaison respectant la Matches(String, String, RegexOptions, TimeSpan) casse qui correspond à n’importe quel mot d’une phrase se terminant par « es ». Il appelle ensuite la Matches(String, String, RegexOptions, TimeSpan) méthode pour effectuer une comparaison ne respectant pas la casse du modèle avec la chaîne d’entrée. Dans les deux cas, l’intervalle de délai d’attente est défini sur une seconde. Comme le montre la sortie, les deux méthodes retournent des résultats différents.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      try {
         foreach (Match match in Regex.Matches(sentence, pattern,
                                               RegexOptions.None,
                                               TimeSpan.FromSeconds(1)))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {
         // Do Nothing: Assume that timeout represents no match.
      }
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      try { 
         foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {}
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern, 
                                               RegexOptions.None, 
                                               TimeSpan.FromSeconds(1))
         Try
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Catch e As RegexMatchTimeoutException
            ' Do Nothing: Assume that timeout represents no match.
         End Try
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      Try
         For Each match As Match In Regex.Matches(sentence, pattern, 
                                                  RegexOptions.IgnoreCase,
                                                  TimeSpan.FromSeconds(1))
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Next
      Catch de As RegexMatchTimeoutException
         ' Do Nothing: Assume that timeout represents no match.
      End Try
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

Le modèle d'expression régulière \b\w+es\b est défini comme indiqué dans le tableau suivant.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.
es Mettre en correspondance la chaîne littérale « es ».
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Matches(String, String, RegexOptions, TimeSpan) méthode est similaire à la Match(String, String, RegexOptions, TimeSpan) méthode, sauf qu’elle retourne des informations sur toutes les correspondances trouvées dans la chaîne d’entrée, au lieu d’une seule correspondance. Il équivaut au code suivant :

   try {
      Match match = Regex.Match(input, pattern, options,
                                TimeSpan.FromSeconds(1));
      while (match.Success) {
            // Handle match here...

            match = match.NextMatch();
      }  
   }
   catch (RegexMatchTimeoutException) {
      // Do nothing: assume that exception represents no match.
   }
   Try
      Dim match As Match = Regex.Match(input, pattern, options, 
                                       TimeSpan.FromSeconds(1))
      Do While match.Success
            ' Handle match here...

            match = match.NextMatch()
      Loop  
   Catch e As RegexMatchTimeoutException
      ' Do nothing: assume that exception represents no match.
   End Try

Les méthodes statiques Matches sont équivalentes à la construction d’un Regex objet avec le modèle d’expression régulière spécifié et à l’appel de la méthode Matchesd’instance.

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez .NET Regular Expressions and Regular Expression Language - Quick Reference.

La Matches méthode utilise l’évaluation différée pour remplir l’objet retourné MatchCollection . L’accès aux membres de cette collection, tels que MatchCollection.Count et MatchCollection.CopyTo provoque le remplissage immédiat de la collection. Pour tirer parti de l’évaluation différée, vous devez itérer la collection à l’aide d’une construction telle que foreach C# et For Each...Next dans Visual Basic.

En raison de son évaluation différée, l’appel de la Matches méthode ne lève pas d’exception RegexMatchTimeoutException . Toutefois, une exception est levée lorsqu’une opération est effectuée sur l’objet MatchCollection retourné par cette méthode, si une opération correspondante dépasse cet intervalle de délai d’attente spécifié par lematchTimeout paramètre.

Notes pour les appelants

Nous vous recommandons de définir le matchTimeout paramètre sur une valeur appropriée, par exemple deux secondes. Si vous désactivez les délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes :

  • Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose de texte statique. Cela exclut le texte qui a été entré dynamiquement par les utilisateurs.

  • Lorsque le modèle d’expression régulière a été soigneusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.

  • Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer un retour arrière excessif lors du traitement d’une correspondance proche.

Voir aussi

S’applique à

Matches(String, String, RegexOptions)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifique, en utilisant les options de correspondance spécifiées.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String, options As RegexOptions) As MatchCollection

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison de bits de valeurs d'énumération qui spécifient des options pour la correspondance.

Retours

MatchCollection

Collection des objets Match trouvés par la recherche. Si aucune correspondance n'est trouvée, la méthode retourne un objet de collection vide.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

input ou pattern est null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

Exemples

L’exemple suivant appelle la Matches(String, String) méthode pour identifier n’importe quel mot dans une phrase qui se termine par « es », puis appelle la Matches(String, String, RegexOptions) méthode pour effectuer une comparaison ne respectant pas la casse du modèle avec la chaîne d’entrée. Comme le montre la sortie, les deux méthodes retournent des résultats différents.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      For Each match As Match In Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

Le modèle d'expression régulière \b\w+es\b est défini comme indiqué dans le tableau suivant.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.
es Mettre en correspondance la chaîne littérale « es ».
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Matches(String, String, RegexOptions) méthode est similaire à la Match(String, String, RegexOptions) méthode, sauf qu’elle retourne des informations sur toutes les correspondances trouvées dans la chaîne d’entrée, au lieu d’une seule correspondance. Il équivaut au code suivant :

Match match = Regex.Match(input, pattern, options);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}
Dim match As Match = Regex.Match(input, pattern, options)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Les méthodes statiques Matches sont équivalentes à la construction d’un Regex objet avec le modèle d’expression régulière spécifié et à l’appel de la méthode Matchesd’instance.

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez .NET Regular Expressions and Regular Expression Language - Quick Reference.

La Matches méthode utilise l’évaluation différée pour remplir l’objet retourné MatchCollection . L’accès aux membres de cette collection, tels que MatchCollection.Count et MatchCollection.CopyTo provoque le remplissage immédiat de la collection. Pour tirer parti de l’évaluation différée, vous devez itérer la collection à l’aide d’une construction telle que foreach C# et For Each...Next dans Visual Basic.

En raison de son évaluation différée, l’appel de la Matches(String, String) méthode ne lève pas d’exception RegexMatchTimeoutException . Toutefois, l’exception est levée lorsqu’une opération est effectuée sur l’objet MatchCollection retourné par cette méthode, si un intervalle de délai d’attente est défini par la propriété « REGEX_DEFAULT_MATCH_TIMEOUT » du domaine d’application actuel et qu’une opération correspondante dépasse cet intervalle de délai d’attente.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode de temporisation, est utilisée. La méthode statique recommandée pour récupérer plusieurs correspondances de modèle est Matches(String, String, RegexOptions, TimeSpan), qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Matches(String, Int32)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière, en commençant à la position de démarrage spécifiée dans la chaîne.

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, int startat);
public System.Text.RegularExpressions.MatchCollection Matches (string input, int startat);
member this.Matches : string * int -> System.Text.RegularExpressions.MatchCollection
Public Function Matches (input As String, startat As Integer) As MatchCollection

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.

startat
Int32

Position du caractère dans la chaîne d'entrée à partir duquel commencer la recherche.

Retours

MatchCollection

Collection des objets Match trouvés par la recherche. Si aucune correspondance n'est trouvée, la méthode retourne un objet de collection vide.

Exceptions

input a la valeur null.

startat est inférieur à zéro ou supérieur à la longueur de input.

Exemples

L’exemple suivant utilise la Match(String) méthode pour rechercher le premier mot dans une phrase qui se termine par « es », puis appelle la Matches(String, Int32) méthode pour identifier les mots supplémentaires qui se terminent par « es ».

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes and uses our paper?";
      
      // Get the first match.
      Match match = rgx.Match(sentence);
      if (match.Success) {
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", 
                           match.Value, match.Index);
         // Get any additional matches.
         foreach (Match m in rgx.Matches(sentence, match.Index + match.Length))
            Console.WriteLine("Also found '{0}' at position {1}", 
                              m.Value, m.Index);
      }   
   }
}
// The example displays the following output:
//       Found first 'es' in 'writes' at position 4
//       Also found 'notes' at position 17
//       Also found 'uses' at position 27
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes and uses our paper?"
      
      ' Get the first match.
      Dim match As Match = rgx.Match(sentence)
      If match.Success Then
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", _
                           match.Value, match.Index)
         ' Get any additional matches.
         For Each match In rgx.Matches(sentence, match.Index + match.Length)
            Console.WriteLine("Also found '{0}' at position {1}", _
                              match.Value, match.Index)
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Found first 'es' in 'writes' at position 4
'       Also found 'notes' at position 17
'       Also found 'uses' at position 27

Le modèle d'expression régulière \b\w+es\b est défini comme indiqué dans le tableau suivant.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.
es Mettre en correspondance la chaîne littérale « es ».
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Matches(String, Int32) méthode est similaire à la Match(String, Int32) méthode, sauf qu’elle retourne des informations sur toutes les correspondances trouvées dans la chaîne d’entrée, au lieu d’une seule correspondance. Il équivaut au code suivant :

Match match = regex.Match(input, startAt);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}
Dim match As Match = regex.Match(input, startAt)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Modèle d’expression régulière pour lequel la Matches(String, Int32) méthode recherche est définie par l’appel à l’un des constructeurs de Regex classe. Pour plus d’informations sur les éléments qui peuvent former un modèle d’expression régulière, consultez langage d’expression régulière - Référence rapide.

Pour plus d’informations sur startat, consultez la section Notes de Match(String, Int32).

La Matches méthode utilise l’évaluation différée pour remplir l’objet retourné MatchCollection . L’accès aux membres de cette collection, tels que MatchCollection.Count et MatchCollection.CopyTo provoque le remplissage immédiat de la collection. Pour tirer parti de l’évaluation différée, vous devez itérer la collection à l’aide d’une construction telle que foreach C# et For Each...Next dans Visual Basic.

En raison de son évaluation différée, l’appel de la Matches(String, Int32) méthode ne lève pas d’exception RegexMatchTimeoutException . Toutefois, l’exception est levée lorsqu’une opération est effectuée sur l’objet MatchCollection retourné par cette méthode, si la MatchTimeout propriété n’est pas Regex.InfiniteMatchTimeout et qu’une opération correspondante dépasse l’intervalle de délai d’attente.

Voir aussi

S’applique à

Matches(String)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière.

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input);
public System.Text.RegularExpressions.MatchCollection Matches (string input);
member this.Matches : string -> System.Text.RegularExpressions.MatchCollection
Public Function Matches (input As String) As MatchCollection

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.

Retours

MatchCollection

Collection des objets Match trouvés par la recherche. Si aucune correspondance n'est trouvée, la méthode retourne un objet de collection vide.

Exceptions

input a la valeur null.

Exemples

L’exemple suivant utilise la Matches(String) méthode pour identifier les mots d’une phrase qui se terminent par « es ».

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes?";
      
      foreach (Match match in rgx.Matches(sentence))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes?"
      
      For Each match As Match In rgx.Matches(sentence)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

Le modèle d'expression régulière \b\w+es\b est défini comme indiqué dans le tableau suivant.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.
es Mettre en correspondance la chaîne littérale « es ».
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Matches(String) méthode est similaire à la Match(String) méthode, sauf qu’elle retourne des informations sur toutes les correspondances trouvées dans la chaîne d’entrée, au lieu d’une seule correspondance. Il équivaut au code suivant :

Match match = regex.Match(input);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}
Dim match As Match = regex.Match(input)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

La collection inclut uniquement les correspondances et se termine au premier non-correspondance.

Modèle d’expression régulière pour lequel la Matches(String) méthode recherche est définie par l’appel à l’un des constructeurs de Regex classe. Pour plus d’informations sur les éléments qui peuvent former un modèle d’expression régulière, consultez langage d’expression régulière - Référence rapide.

La Matches méthode utilise l’évaluation différée pour remplir l’objet retourné MatchCollection . L’accès aux membres de cette collection, tels que MatchCollection.Count et MatchCollection.CopyTo provoque le remplissage immédiat de la collection. Pour tirer parti de l’évaluation différée, vous devez itérer la collection à l’aide d’une construction telle que foreach C# et For Each...Next dans Visual Basic.

En raison de son évaluation différée, l’appel de la Matches(String) méthode ne lève pas d’exception RegexMatchTimeoutException . Toutefois, l’exception est levée lorsqu’une opération est effectuée sur l’objet MatchCollection retourné par cette méthode, si la MatchTimeout propriété n’est pas Regex.InfiniteMatchTimeout et qu’une opération correspondante dépasse l’intervalle de délai d’attente.

Voir aussi

S’applique à

Matches(String, String)

Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifiée.

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern);
public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern);
static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection
Public Shared Function Matches (input As String, pattern As String) As MatchCollection

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

Retours

MatchCollection

Collection des objets Match trouvés par la recherche. Si aucune correspondance n'est trouvée, la méthode retourne un objet de collection vide.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

input ou pattern est null.

Exemples

L’exemple suivant utilise la Matches(String, String) méthode pour identifier n’importe quel mot dans une phrase qui se termine par « es ».

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "Who writes these notes?";
      
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "Who writes these notes?"
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

Le modèle d'expression régulière \b\w+es\b est défini comme indiqué dans le tableau suivant.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.
es Mettre en correspondance la chaîne littérale « es ».
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Matches(String, String) méthode est similaire à la Match(String, String) méthode, sauf qu’elle retourne des informations sur toutes les correspondances trouvées dans la chaîne d’entrée, au lieu d’une seule correspondance. Il équivaut au code suivant :

Match match = Regex.Match(input, pattern);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Les méthodes statiques Matches sont équivalentes à la construction d’un Regex objet avec le modèle d’expression régulière spécifié et à l’appel de la méthode Matchesd’instance.

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez .NET Regular Expressions and Regular Expression Language - Quick Reference.

La Matches méthode utilise l’évaluation différée pour remplir l’objet retourné MatchCollection . L’accès aux membres de cette collection, tels que MatchCollection.Count et MatchCollection.CopyTo provoque le remplissage immédiat de la collection. Pour tirer parti de l’évaluation différée, vous devez itérer la collection à l’aide d’une construction telle que foreach C# et For Each...Next dans Visual Basic.

En raison de son évaluation différée, l’appel de la Matches(String, String) méthode ne lève pas d’exception RegexMatchTimeoutException . Toutefois, l’exception est levée lorsqu’une opération est effectuée sur l’objet MatchCollection retourné par cette méthode, si un intervalle de délai d’attente est défini par la propriété « REGEX_DEFAULT_MATCH_TIMEOUT » du domaine d’application actuel et qu’une opération correspondante dépasse cet intervalle de délai d’attente.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode de temporisation, est utilisée. La méthode statique recommandée pour récupérer plusieurs correspondances de modèle est Matches(String, String, RegexOptions, TimeSpan), qui vous permet de spécifier l’intervalle de délai d’attente.

Voir aussi

S’applique à