Partager via

Regex.IsMatch Méthode

  • Référence

Définition

Espace de noms:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Assembly:
netstandard.dll

Indique si l’expression régulière trouve une correspondance dans la chaîne d’entrée.

Surcharges

IsMatch(String, String, RegexOptions, TimeSpan)

Indique si l’expression régulière spécifiée trouve une correspondance dans la chaîne d’entrée spécifiée, à l’aide des options de correspondance et de l’intervalle de délai d’attente spécifiés.
IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée, à l’aide des options de correspondance et de l’intervalle de délai d’attente spécifiés.
IsMatch(String, String, RegexOptions)

Indique si l’expression régulière spécifiée trouve une correspondance dans la chaîne d’entrée spécifiée, à l’aide des options de correspondance spécifiées.
IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée, à l’aide des options de correspondance spécifiées.
IsMatch(String, String)

Indique si l’expression régulière spécifiée trouve une correspondance dans la chaîne d’entrée spécifiée.
IsMatch(ReadOnlySpan<Char>, Int32)

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans une étendue d’entrée spécifiée.
IsMatch(ReadOnlySpan<Char>, String)

Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée.
IsMatch(String, Int32)

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans la chaîne d’entrée spécifiée, en commençant à la position de départ spécifiée dans la chaîne.
IsMatch(String)

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans une chaîne d’entrée spécifiée.
IsMatch(ReadOnlySpan<Char>)

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans une étendue d’entrée spécifiée.

IsMatch(String, String, RegexOptions, TimeSpan)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée trouve une correspondance dans la chaîne d’entrée spécifiée, à l’aide des options de correspondance et de l’intervalle de délai d’attente spécifiés.

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

Paramètres

input
String

Chaîne à rechercher une correspondance.

pattern
String

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

options
RegexOptions

Combinaison de bits des valeurs d’énumération qui fournissent des options de correspondance.

matchTimeout
TimeSpan

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

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentException

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

ArgumentNullException

input ou pattern est null.

ArgumentOutOfRangeException

options n’est pas une valeur de RegexOptions valide.

-ou-

matchTimeout est négatif, zéro ou supérieur à environ 24 jours.

RegexMatchTimeoutException

Un délai d’attente s’est produit.

Exemples

L’exemple suivant illustre l’utilisation de la méthode IsMatch(String, String, RegexOptions, TimeSpan) pour déterminer si une chaîne est un numéro de partie valide. L’expression régulière suppose que le numéro de partie a un format spécifique qui se compose de trois jeux de caractères séparés par des traits d’union. Le premier jeu, qui contient quatre caractères, doit se composer d’un caractère alphanumérique suivi de deux caractères numériques suivis d’un caractère alphanumérique. Le deuxième jeu, qui se compose de trois caractères, doit être numérique. Le troisième jeu, composé de quatre caractères, doit avoir trois caractères numériques suivis d’un caractère alphanumérique. La mise en correspondance du modèle d’expression régulière doit impliquer une recherche minimale dans la chaîne d’entrée, de sorte que la méthode définit un intervalle de délai d’attente de 500 millisecondes.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468a", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
      foreach (string partNumber in partNumbers)
         try {
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, 
                              Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase) 
                                            ? "is" : "is not", TimeSpan.FromMilliseconds(500));
         }
         catch (RegexMatchTimeoutException e) {
            Console.WriteLine("Timeout after {0} seconds matching {1}.",
                              e.MatchTimeout, e.Input);
         }
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468a", 
                                      "_A90-123-129X", "12345-KKA-1230", 
                                      "0919-2893-1256" }
      Dim pattern As String = "^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$"
      For Each partNumber As String In partNumbers
         Try
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, _
                              IIF(Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase), _
                                  "is", "is not"),
                              TimeSpan.FromMilliseconds(500))
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("Timeout after {0} seconds matching {1}.",
                              e.MatchTimeout, e.Input)
         End Try
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468a is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

Le modèle d’expression régulière est :

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$

Le tableau suivant montre comment le modèle d’expression régulière est interprété.

Modèle Description
^ Commencez la correspondance au début de la chaîne.
[A-Z0-9] Faire correspondre n’importe quel caractère alphabétique unique de A via Zou tout caractère numérique.
\d{2} Mettre en correspondance deux caractères numériques.
[A-Z0-9] Faire correspondre n’importe quel caractère alphabétique unique de A via Zou tout caractère numérique.
- Mettre en correspondance un trait d’union.
\d{3} Mettre en correspondance exactement trois caractères numériques.
(-\d{3}){2} Recherchez un trait d’union suivi de trois caractères numériques et faites correspondre deux occurrences de ce modèle.
[A-Z0-9] Faire correspondre n’importe quel caractère alphabétique unique de A via Zou tout caractère numérique.
$ Terminez la correspondance à la fin de la chaîne.

L’appel de la méthode IsMatch(String, String, RegexOptions, TimeSpan) avec le paramètre options défini sur RegexOptions.IgnoreCase équivaut à définir l’expression régulière suivante :

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]

Pour une comparaison, consultez l’exemple de la méthode IsMatch(String, String).

Remarques

La méthode IsMatch est généralement utilisée pour valider une chaîne ou pour s’assurer qu’une chaîne est conforme à un modèle particulier sans récupérer cette chaîne pour une manipulation ultérieure. Si vous souhaitez déterminer si une ou plusieurs chaînes correspondent à un modèle d’expression régulière, puis récupérez-les pour une manipulation ultérieure, appelez la méthode Match ou Matches.

La méthode IsMatch(String, String, RegexOptions, TimeSpan) statique équivaut à construire un objet Regex avec le modèle d’expression régulière spécifié par pattern et les options d’expression régulière spécifiées par options et en appelant la méthode d’instance IsMatch(String). Ce modèle d’expression régulière est mis en cache pour une récupération rapide par le moteur d’expression régulière.

Le paramètre pattern 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 - Informations de référence rapides.

Le paramètre matchTimeout spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant d’expirer. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui s’appuient sur un retour arrière excessif d’apparaître pour cesser de répondre lorsqu’elles traitent les entrées qui contiennent des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et retour arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une exception RegexMatchTimeoutException. matchTimeout remplace toute valeur de délai d’attente par défaut définie pour le domaine d’application dans lequel la méthode s’exécute.

Notes pour les appelants

Nous vous recommandons de définir le paramètre matchTimeout 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 à

IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée, à l’aide des options de correspondance et de l’intervalle de délai d’attente spécifiés.

public:
 static bool IsMatch(ReadOnlySpan<char> input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static bool IsMatch (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member IsMatch : ReadOnlySpan<char> * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> bool
Public Shared Function IsMatch (input As ReadOnlySpan(Of Char), pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue à rechercher une correspondance.

pattern
String

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

options
RegexOptions

Combinaison de bits des valeurs d’énumération qui fournissent des options de correspondance.

matchTimeout
TimeSpan

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

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentException

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

ArgumentNullException

pattern est null

RegexMatchTimeoutException

Un délai d’attente s’est produit.

ArgumentOutOfRangeException

options n’est pas dans une valeur RegexOptions valide ou matchTimeout est négative, zéro ou supérieure à environ 24 jours.

S’applique à

IsMatch(String, String, RegexOptions)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée trouve une correspondance dans la chaîne d’entrée spécifiée, à l’aide des options de correspondance spécifiées.

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

Paramètres

input
String

Chaîne à rechercher une correspondance.

pattern
String

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

options
RegexOptions

Combinaison de bits des valeurs d’énumération qui fournissent des options de correspondance.

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentException

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

ArgumentNullException

input ou pattern est null.

ArgumentOutOfRangeException

options n’est pas une valeur de RegexOptions valide.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Exemples

L’exemple suivant illustre l’utilisation de la méthode IsMatch(String, String) pour déterminer si une chaîne est un numéro de partie valide. L’expression régulière suppose que le numéro de partie a un format spécifique qui se compose de trois jeux de caractères séparés par des traits d’union. Le premier jeu, qui contient quatre caractères, doit se composer d’un caractère alphanumérique suivi de deux caractères numériques suivis d’un caractère alphanumérique. Le deuxième jeu, qui se compose de trois caractères, doit être numérique. Le troisième jeu, composé de quatre caractères, doit avoir trois caractères numériques suivis d’un caractère alphanumérique.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468a", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
      foreach (string partNumber in partNumbers)
         Console.WriteLine("{0} {1} a valid part number.", 
                           partNumber, 
                           Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase) 
                                         ? "is" : "is not");
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468a", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim pattern As String = "^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$"
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase), _
                               "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468a is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

Le modèle d’expression régulière est :

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$

Le tableau suivant montre comment le modèle d’expression régulière est interprété.

Modèle Description
^ Commencez la correspondance au début de la chaîne.
[A-Z0-9] Faire correspondre n’importe quel caractère alphabétique unique de A via Zou tout caractère numérique.
\d{2} Mettre en correspondance deux caractères numériques.
[A-Z0-9] Faire correspondre n’importe quel caractère alphabétique unique de A via Zou tout caractère numérique.
- Mettre en correspondance un trait d’union.
\d{3} Mettre en correspondance exactement trois caractères numériques.
(-\d{3}){2} Recherchez un trait d’union suivi de trois caractères numériques et faites correspondre deux occurrences de ce modèle..
[A-Z0-9] Faire correspondre n’importe quel caractère alphabétique unique de A via Zou tout caractère numérique.
$ Terminez la correspondance à la fin de la chaîne.

L’appel de la méthode IsMatch(String, String, RegexOptions) avec le paramètre options défini sur RegexOptions.IgnoreCase équivaut à définir l’expression régulière suivante :

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]

Pour une comparaison, consultez l’exemple de la méthode IsMatch(String, String).

Remarques

La méthode IsMatch est généralement utilisée pour valider une chaîne ou pour s’assurer qu’une chaîne est conforme à un modèle particulier sans récupérer cette chaîne pour une manipulation ultérieure. Si vous souhaitez déterminer si une ou plusieurs chaînes correspondent à un modèle d’expression régulière, puis récupérez-les pour une manipulation ultérieure, appelez la méthode Match ou Matches.

La méthode IsMatch(String, String, RegexOptions) statique équivaut à construire un objet Regex avec le modèle d’expression régulière spécifié par pattern et les options d’expression régulière spécifiées par options et en appelant la méthode d’instance IsMatch(String). Ce modèle d’expression régulière est mis en cache pour une récupération rapide par le moteur d’expression régulière.

Le paramètre pattern 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 - Informations de référence rapides.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

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 une valeur de délai d’attente n’a pas é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 vérifier qu’une correspondance de modèle est IsMatch(String, String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée, à l’aide des options de correspondance spécifiées.

public:
 static bool IsMatch(ReadOnlySpan<char> input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static bool IsMatch (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member IsMatch : ReadOnlySpan<char> * string * System.Text.RegularExpressions.RegexOptions -> bool
Public Shared Function IsMatch (input As ReadOnlySpan(Of Char), pattern As String, options As RegexOptions) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue à rechercher une correspondance.

pattern
String

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

options
RegexOptions

Combinaison de bits des valeurs d’énumération qui fournissent des options de correspondance.

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentException

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

ArgumentNullException

pattern est null

RegexMatchTimeoutException

Un délai d’attente s’est produit.

ArgumentOutOfRangeException

options n’est pas dans une valeur de RegexOptions valide.

S’applique à

IsMatch(String, String)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée trouve une correspondance dans la chaîne d’entrée spécifiée.

public:
 static bool IsMatch(System::String ^ input, System::String ^ pattern);
public static bool IsMatch (string input, string pattern);
static member IsMatch : string * string -> bool
Public Shared Function IsMatch (input As String, pattern As String) As Boolean

Paramètres

input
String

Chaîne à rechercher une correspondance.

pattern
String

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

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentException

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

ArgumentNullException

input ou pattern est null.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Exemples

L’exemple suivant illustre l’utilisation de la méthode IsMatch(String, String) pour déterminer si une chaîne est un numéro de partie valide. L’expression régulière suppose que le numéro de partie a un format spécifique qui se compose de trois jeux de caractères séparés par des traits d’union. Le premier jeu, qui contient quatre caractères, doit se composer d’un caractère alphanumérique suivi de deux caractères numériques suivis d’un caractère alphanumérique. Le deuxième jeu, qui se compose de trois caractères, doit être numérique. Le troisième jeu, composé de quatre caractères, doit avoir trois caractères numériques suivis d’un caractère alphanumérique.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468A", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      string pattern = @"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$";
      foreach (string partNumber in partNumbers)
         Console.WriteLine("{0} {1} a valid part number.", 
                           partNumber, 
                           Regex.IsMatch(partNumber, pattern) ? "is" : "is not");
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468A", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim pattern As String = "^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$"
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(Regex.IsMatch(partNumber, pattern), "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468A is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

Le modèle d’expression régulière est :

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

Le tableau suivant montre comment le modèle d’expression régulière est interprété.

Modèle Description
^ Commencez la correspondance au début de la ligne.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
\d{2} Mettre en correspondance deux caractères numériques.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
- Mettre en correspondance un trait d’union.
\d{3} Mettre en correspondance exactement trois caractères numériques.
(-\d{3}){2} Recherchez un trait d’union suivi de trois caractères numériques et faites correspondre deux occurrences de ce modèle.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
$ Terminez la correspondance à la fin de la ligne.

Remarques

La méthode IsMatch est généralement utilisée pour valider une chaîne ou pour s’assurer qu’une chaîne est conforme à un modèle particulier sans récupérer cette chaîne pour une manipulation ultérieure. Si vous souhaitez déterminer si une ou plusieurs chaînes correspondent à un modèle d’expression régulière, puis récupérez-les pour une manipulation ultérieure, appelez la méthode Match ou Matches.

La méthode IsMatch(String, String) statique équivaut à construire un objet Regex avec le modèle d’expression régulière spécifié par pattern et en appelant la méthode d’instance IsMatch(String). Ce modèle d’expression régulière est mis en cache pour une récupération rapide par le moteur d’expression régulière.

Le paramètre pattern 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 - Informations de référence rapides.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

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 la méthode est appelée. Si une valeur de délai d’attente n’a pas é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 vérifier qu’une correspondance de modèle est IsMatch(String, String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

IsMatch(ReadOnlySpan<Char>, Int32)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans une étendue d’entrée spécifiée.

public:
 bool IsMatch(ReadOnlySpan<char> input, int startat);
public bool IsMatch (ReadOnlySpan<char> input, int startat);
member this.IsMatch : ReadOnlySpan<char> * int -> bool
Public Function IsMatch (input As ReadOnlySpan(Of Char), startat As Integer) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue à rechercher une correspondance.

startat
Int32

Position de caractère de base zéro à laquelle démarrer la recherche.

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

RegexMatchTimeoutException

Un délai d’attente s’est produit.

S’applique à

IsMatch(ReadOnlySpan<Char>, String)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée trouve une correspondance dans l’étendue d’entrée spécifiée.

public:
 static bool IsMatch(ReadOnlySpan<char> input, System::String ^ pattern);
public static bool IsMatch (ReadOnlySpan<char> input, string pattern);
static member IsMatch : ReadOnlySpan<char> * string -> bool
Public Shared Function IsMatch (input As ReadOnlySpan(Of Char), pattern As String) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue à rechercher une correspondance.

pattern
String

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

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentException

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

ArgumentNullException

pattern est null

RegexMatchTimeoutException

Un délai d’attente s’est produit.

S’applique à

IsMatch(String, Int32)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans la chaîne d’entrée spécifiée, en commençant à la position de départ spécifiée dans la chaîne.

public:
 bool IsMatch(System::String ^ input, int startat);
public bool IsMatch (string input, int startat);
member this.IsMatch : string * int -> bool
Public Function IsMatch (input As String, startat As Integer) As Boolean

Paramètres

input
String

Chaîne à rechercher une correspondance.

startat
Int32

Position de caractère à laquelle démarrer la recherche.

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentNullException

input est null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Exemples

L’exemple suivant illustre l’utilisation de la méthode IsMatch(String, Int32) pour déterminer si une chaîne est un numéro de partie valide. Il recherche un numéro de partie qui suit un signe deux-points (:) caractère dans une chaîne. La méthode IndexOf(Char) est utilisée pour déterminer la position du caractère deux-points, qui est ensuite passée à la méthode IsMatch(String, Int32). L’expression régulière suppose que le numéro de partie a un format spécifique qui se compose de trois jeux de caractères séparés par des traits d’union. Le premier jeu, qui contient quatre caractères, doit se composer d’un caractère alphanumérique suivi de deux caractères numériques suivis d’un caractère alphanumérique. Le deuxième jeu, qui se compose de trois caractères, doit être numérique. Le troisième jeu, composé de quatre caractères, doit avoir trois caractères numériques suivis d’un caractère alphanumérique.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "Part Number: 1298-673-4192", "Part No: A08Z-931-468A", 
                              "_A90-123-129X", "123K-000-1230", 
                              "SKU: 0919-2893-1256" };
      Regex rgx = new Regex(@"[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$");
      foreach (string partNumber in partNumbers)
      {
         int start = partNumber.IndexOf(':');
         if (start >= 0)
         {
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, 
                              rgx.IsMatch(partNumber, start) ? "is" : "is not");
         }
         else
         {
            Console.WriteLine("Cannot find starting position in {0}.", partNumber);
         }
      }
   }
}
// The example displays the following output:
//       Part Number: 1298-673-4192 is a valid part number.
//       Part No: A08Z-931-468A is a valid part number.
//       Cannot find starting position in _A90-123-129X.
//       Cannot find starting position in 123K-000-1230.
//       SKU: 0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "Part Number: 1298-673-4192", "Part No: A08Z-931-468A", _
                                      "_A90-123-129X", "123K-000-1230", _
                                      "SKU: 0919-2893-1256" }
      Dim rgx As New Regex("[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$")
      For Each partNumber As String In partNumbers
         Dim start As Integer = partNumber.IndexOf(":"c)
         If start >= 0 Then 
            Console.WriteLine("{0} {1} a valid part number.", _
                              partNumber, _
                              IIF(rgx.IsMatch(partNumber, start), "is", "is not"))
         Else
            Console.WriteLine("Cannot find starting position in {0}.", partNumber)
         End If                              
      Next
   End Sub
End Module
' The example displays the following output:
'       Part Number: 1298-673-4192 is a valid part number.
'       Part No: A08Z-931-468A is a valid part number.
'       Cannot find starting position in _A90-123-129X.
'       Cannot find starting position in 123K-000-1230.
'       SKU: 0919-2893-1256 is not a valid part number.

Le modèle d’expression régulière est :

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

Le tableau suivant montre comment le modèle d’expression régulière est interprété.

Modèle Description
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
\d{2} Mettre en correspondance deux caractères numériques.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
- Mettre en correspondance un trait d’union.
\d{3} Mettre en correspondance exactement trois caractères numériques.
(-\d{3}){2} Recherchez un trait d’union suivi de trois caractères numériques et faites correspondre deux occurrences de ce modèle.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
$ Terminez la correspondance à la fin de la ligne.

Remarques

La méthode IsMatch est généralement utilisée pour valider une chaîne ou pour s’assurer qu’une chaîne est conforme à un modèle particulier sans récupérer cette chaîne pour une manipulation ultérieure. Si vous souhaitez déterminer si une ou plusieurs chaînes correspondent à un modèle d’expression régulière, puis récupérez-les pour une manipulation ultérieure, appelez la méthode Match ou Matches.

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

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan). Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Voir aussi

S’applique à

IsMatch(String)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans une chaîne d’entrée spécifiée.

public:
 bool IsMatch(System::String ^ input);
public bool IsMatch (string input);
member this.IsMatch : string -> bool
Public Function IsMatch (input As String) As Boolean

Paramètres

input
String

Chaîne à rechercher une correspondance.

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

ArgumentNullException

input est null.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Exemples

L’exemple suivant illustre l’utilisation de la méthode IsMatch(String) pour déterminer si une chaîne est un numéro de partie valide. L’expression régulière suppose que le numéro de partie a un format spécifique qui se compose de trois jeux de caractères séparés par des traits d’union. Le premier jeu, qui contient quatre caractères, doit se composer d’un caractère alphanumérique suivi de deux caractères numériques suivis d’un caractère alphanumérique. Le deuxième jeu, qui se compose de trois caractères, doit être numérique. Le troisième jeu, composé de quatre caractères, doit avoir trois caractères numériques suivis d’un caractère alphanumérique.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468A", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      Regex rgx = new Regex(@"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$");
      foreach (string partNumber in partNumbers)
         Console.WriteLine("{0} {1} a valid part number.", 
                           partNumber, 
                           rgx.IsMatch(partNumber) ? "is" : "is not");
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468A", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim rgx As New Regex("^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$")
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(rgx.IsMatch(partNumber), "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468A is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

Le modèle d’expression régulière est :

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

Le tableau suivant montre comment le modèle d’expression régulière est interprété.

Modèle Description
^ Commencez la correspondance au début de la ligne.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
\d{2} Mettre en correspondance deux caractères numériques.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
- Mettre en correspondance un trait d’union.
\d{3} Mettre en correspondance exactement trois caractères numériques.
(-\d{3}){2} Recherchez un trait d’union suivi de trois caractères numériques et faites correspondre deux occurrences de ce modèle.
[a-zA-Z0-9] Mettre en correspondance un caractère alphabétique unique (a via z ou A par Z) ou un caractère numérique.
$ Terminez la correspondance à la fin de la ligne.

Remarques

La méthode IsMatch est généralement utilisée pour valider une chaîne ou pour s’assurer qu’une chaîne est conforme à un modèle particulier sans récupérer cette chaîne pour une manipulation ultérieure. Si vous souhaitez déterminer si une ou plusieurs chaînes correspondent à un modèle d’expression régulière, puis récupérez-les pour une manipulation ultérieure, appelez la méthode Match ou Matches.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan). Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Voir aussi

S’applique à

IsMatch(ReadOnlySpan<Char>)

Source:
Regex.Match.cs
Source:
Regex.Match.cs
Source:
Regex.Match.cs

Indique si l’expression régulière spécifiée dans le constructeur Regex recherche une correspondance dans une étendue d’entrée spécifiée.

public:
 bool IsMatch(ReadOnlySpan<char> input);
public bool IsMatch (ReadOnlySpan<char> input);
member this.IsMatch : ReadOnlySpan<char> -> bool
Public Function IsMatch (input As ReadOnlySpan(Of Char)) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue à rechercher une correspondance.

Retours

Boolean

true si l’expression régulière trouve une correspondance ; sinon, false.

Exceptions

RegexMatchTimeoutException

Un délai d’attente s’est produit.

S’applique à