Regex.Matches Méthode

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

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

Exemples

L’exemple suivant appelle la Matches(String, String, RegexOptions, TimeSpan) méthode pour effectuer une comparaison respectant la casse qui correspond à n’importe quel mot d’une phrase qui se termine par « es ». Il appelle ensuite la Matches(String, String, RegexOptions, TimeSpan) méthode pour effectuer une comparaison sans respect de 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.

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 revient à construire un Regex objet avec le modèle d’expression régulière spécifié et à appeler la méthode Matchesinstance .

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 Expressions régulières .NET et 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 , entraîne 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 en C# et For Each...Next en 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 entré dynamiquement par les utilisateurs.

• Lorsque le modèle d’expression régulière a été minutieusement 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 une rétroaction excessive lors du traitement d’une quasi-correspondance.

Voir aussi

• Éléments du langage des expressions régulières

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

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

Exemples

L’exemple suivant appelle la Matches(String, String) méthode pour identifier tout mot dans une phrase qui se termine par « es », puis appelle la Matches(String, String, RegexOptions) méthode pour effectuer une comparaison sans respect de 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.

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 revient à construire un Regex objet avec le modèle d’expression régulière spécifié et à appeler la méthode Matchesinstance .

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 Expressions régulières .NET et 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 , entraîne 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 en C# et For Each...Next en 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 d’expirer, 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

• Éléments du langage des expressions régulières

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

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

Exemples

L’exemple suivant utilise la Match(String) méthode pour rechercher le premier mot d’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.

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

Le modèle d’expression régulière pour lequel la Matches(String, Int32) méthode recherche est défini par l’appel à l’un des constructeurs de classe Regex . Pour plus d’informations sur les éléments pouvant 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 Remarques 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 , entraîne 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 en C# et For Each...Next en 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

• Éléments du langage des expressions régulières

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

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

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.

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 à la première non-correspondance.

Le modèle d’expression régulière pour lequel la Matches(String) méthode recherche est défini par l’appel à l’un des constructeurs de classe Regex . Pour plus d’informations sur les éléments pouvant 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 , entraîne 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 en C# et For Each...Next en 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

• Éléments du langage des expressions régulières

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

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

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.

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 revient à construire un Regex objet avec le modèle d’expression régulière spécifié et à appeler la méthode Matchesinstance .

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 Expressions régulières .NET et 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 , entraîne 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 en C# et For Each...Next en 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 d’expirer, 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

• Éléments du langage des expressions régulières