Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Regex, classe

Représente une expression régulière immuable.

System.Object
  System.Text.RegularExpressions.Regex
    En savoir plus...

Espace de noms :  System.Text.RegularExpressions
Assembly :  System (dans System.dll)

[SerializableAttribute]
public class Regex : ISerializable

Le type Regex expose les membres suivants.

  NomDescription
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRegex()Initialise une nouvelle instance de la classe Regex.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRegex(String)Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée.
Méthode protégéeRegex(SerializationInfo, StreamingContext)Initialise une nouvelle instance de la classe Regex à l'aide de données sérialisées.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRegex(String, RegexOptions)Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec des options qui modifient le modèle.
Méthode publiquePris en charge dans .NET pour les applications du Windows StoreRegex(String, RegexOptions, TimeSpan)Initialise une nouvelle instance de la classe Regex pour l'expression régulière spécifiée, avec les options qui modifient le modèle et une valeur qui spécifie la durée pendant laquelle une méthode de modèle doit tenter une correspondance avant son expiration.
Début

  NomDescription
Propriété publiqueMembre statiqueCacheSizeObtient ou définit le nombre maximal d'entrées dans le cache statique actuel des expressions régulières compilées.
Propriété publiquePris en charge dans .NET pour les applications du Windows StoreMatchTimeoutObtient l'intervalle du délai d'attente de l'instance actuelle.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOptionsObtient les options passées dans le constructeur Regex.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRightToLeftObtient une valeur qui indique si l'expression régulière cherche de droite à gauche.
Début

  NomDescription
Méthode publiqueMembre statiqueCompileToAssembly(RegexCompilationInfo[], AssemblyName)Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé.
Méthode publiqueMembre statiqueCompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé avec les attributs spécifiés.
Méthode publiqueMembre statiqueCompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)Compile un ou plusieurs objets Regex spécifiés et un fichier de ressources spécifié dans un assembly nommé avec les attributs spécifiés.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEscapeÉchappe un ensemble minimal de caractères (\, *, +, ?, |, {, [, (,), ^, $,., # et espace blanc) en les remplaçant par leur code d'échappement. Cela indique au moteur d'expressions régulières qu'il doit interpréter ces caractères littéralement, et non comme des métacaractères.
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFinalize Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetGroupNamesRetourne un tableau de noms de groupes de captures pour l'expression régulière.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetGroupNumbersRetourne un tableau des numéros des groupes de captures qui correspondent aux noms des groupes dans un tableau.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupNameFromNumberObtient le nom du groupe qui correspond au numéro de groupe spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupNumberFromNameRetourne le numéro du groupe qui correspond au nom de groupe spécifié.
Méthode protégéeInitializeReferencesInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsMatch(String)Indique si l'expression régulière spécifiée dans le constructeur Regex cherche une correspondance dans une chaîne d'entrée spécifique.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsMatch(String, Int32)Indique si l'expression régulière spécifiée dans le constructeur Regex cherche une correspondance dans la chaîne d'entrée spécifiée, en commençant à la position de départ définie dans la chaîne.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsMatch(String, String)Indique si l'expression régulière spécifiée cherche une correspondance dans la chaîne d'entrée spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsMatch(String, String, RegexOptions)Indique si l'expression régulière spécifiée cherche une correspondance dans la chaîne d'entrée spécifiée, à l'aide des options de correspondance spécifiées.
Méthode publiqueMembre statiquePris en charge dans .NET pour les applications du Windows StoreIsMatch(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 d'un intervalle de délai d'attente spécifiés.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatch(String)Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée dans le constructeur Regex.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatch(String, Int32)Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée dans la chaîne.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatch(String, String)Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatch(String, Int32, Int32)Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée et en recherchant uniquement le nombre spécifié de caractères.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatch(String, String, RegexOptions)Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, à l'aide des options de correspondance spécifiées.
Méthode publiqueMembre statiquePris en charge dans .NET pour les applications du Windows StoreMatch(String, String, RegexOptions, TimeSpan)Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, à l'aide des options de correspondance spécifiées et de l'intervalle de délai d'attente spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatches(String)Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatches(String, Int32)Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière, commençant à la position de démarrage spécifiée dans la chaîne.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatches(String, String)Recherche dans la chaîne d'entrée spécifiée toutes les occurrences d'une expression régulière spécifique.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMatches(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, à l'aide des options de correspondance spécifiées.
Méthode publiqueMembre statiquePris en charge dans .NET pour les applications du Windows StoreMatches(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, à l'aide des options de correspondance spécifiées et de l'intervalle de délai d'attente spécifié.
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMemberwiseCloneCrée une copie superficielle de l'objet Object actuel. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à un modèle d'expression régulière par une chaîne de remplacement spécifique.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, MatchEvaluator)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, Int32)Dans la chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne de remplacement spécifique.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, String)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifique.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, MatchEvaluator)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, MatchEvaluator, Int32)Dans la chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, Int32, Int32)Dans la sous-chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne de remplacement spécifique.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, String, RegexOptions)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifique. Les options spécifiées modifient l'opération correspondante.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, MatchEvaluator, RegexOptions)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. Les options spécifiées modifient l'opération correspondante.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, MatchEvaluator, Int32, Int32)Dans la sous-chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator.
Méthode publiqueMembre statiquePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, String, RegexOptions, TimeSpan)Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifique. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.
Méthode publiqueMembre statiquePris en charge dans .NET pour les applications du Windows StoreReplace(String, String, MatchEvaluator, RegexOptions, TimeSpan)Dans la chaîne d'entrée spécifiée, remplace toutes les sous-chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String)Fractionne une chaîne d'entrée en un tableau de sous-chaînes, aux positions définies par un modèle d'expression régulière spécifié dans le constructeur Regex.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String, Int32)Fractionne une chaîne d'entrée spécifiée un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String, String)Fractionne une chaîne d'entrée en un tableau de sous-chaînes aux positions définies par un modèle d'expression régulière.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String, Int32, Int32)Fractionne une chaîne d'entrée spécifiée un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex. La recherche du modèle d'expression régulière débute à une position de caractère spécifiée dans la chaîne d'entrée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String, String, RegexOptions)Fractionne une chaîne d'entrée en un tableau de sous-chaînes aux positions définies par un modèle d'expression régulière spécifié. Les options spécifiées modifient l'opération correspondante.
Méthode publiqueMembre statiquePris en charge dans .NET pour les applications du Windows StoreSplit(String, String, RegexOptions, TimeSpan)Fractionne une chaîne d'entrée en un tableau de sous-chaînes aux positions définies par un modèle d'expression régulière spécifié. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToStringRetourne le modèle d'expression régulière qui a été passé au constructeur Regex. (Substitue Object.ToString().)
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreUnescapeConvertit les caractères d'échappement dans la chaîne d'entrée.
Méthode protégéePris en charge par XNA FrameworkUseOptionCInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Méthode protégéePris en charge par XNA FrameworkUseOptionRInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Méthode protégéeMembre statiqueValidateMatchTimeoutInfrastructure. Vérifie si un intervalle de délai d'attente est compris dans une plage acceptable.
Début

  NomDescription
Champ protégéPris en charge par XNA FrameworkcapnamesInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Champ protégéPris en charge par XNA FrameworkcapsInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Champ protégéPris en charge par XNA FrameworkcapsizeInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Champ protégéPris en charge par XNA FrameworkcapslistInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Champ protégéfactoryInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Champ publicMembre statiquePris en charge dans .NET pour les applications du Windows StoreInfiniteMatchTimeoutSpécifie qu'une opération de critères spéciaux ne doit pas expirer.
Champ protégéinternalMatchTimeoutInfrastructure. Durée maximale pouvant s'écouler lors d'une opération de correspondance de modèle avant que l'opération expire.
Champ protégéPris en charge par XNA FrameworkpatternInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Champ protégéPris en charge par XNA FrameworkroptionsInfrastructure. Utilisé par un objet Regex généré par la méthode CompileToAssembly.
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéeISerializable.GetObjectDataInfrastructure. Remplit un objet SerializationInfo avec les données nécessaires pour désérialiser l'objet Regex actuel.
Début

La classe Regex représente le moteur d'expressions régulières du .NET Framework. Il peut être utilisé pour analyser rapidement des volumes importants de texte pour rechercher des modèles de caractères spécifiques ; extraire, modifier, remplacer, ou supprimer des sous-chaînes de texte ; et ajouter les chaînes extraites à une collection de générer un rapport.

RemarqueRemarque

Si votre intérêt principal est de valider une chaîne en déterminant si elle se conforme à un modèle particulier, vous pouvez utiliser la classe System.Configuration.RegexStringValidator.

Pour utiliser des expressions régulières, vous définissez le modèle que vous souhaitez identifier dans un flux de texte à l'aide de la syntaxe documentée dans Langage des expressions régulières - Aide-mémoire. Ensuite, vous pouvez éventuellement instancier un objet Regex. Enfin, appelez une méthode qui exécute une opération, telle que remplacer le texte qui correspond au modèle d'expression régulière, ou identifier une correspondance de modèle.

Comparaison entre la méthode Regex et la méthode String

La classe System.String inclut plusieurs méthodes de comparaison et recherche que vous pouvez utiliser pour exécuter les critères spéciaux avec le texte. Par exemple, les méthodes String.Contains, String.EndsWith et String.StartsWith déterminent si une instance de chaîne contient une sous-chaîne spécifiée ; et les méthodes String.IndexOf, String.IndexOfAny, String.LastIndexOf et String.LastIndexOfAny retournent la position de départ d'une sous-chaîne spécifiée dans une chaîne. Utilisez les méthodes de la classe System.String lorsque vous recherchez une chaîne spécifique. Utilisez la classe Regex lorsque vous recherchez un modèle spécifique dans une chaîne. Pour plus d'informations et d'exemples, consultez Expressions régulières du .NET Framework.

Retour sur Notes

Comparaison entre la méthode statique et la méthode d'instance

Après avoir défini un modèle d'expression régulière, vous pouvez contribuer au moteur des expressions régulières de deux façons :

  • En instanciant un objet Regex qui représente l'expression régulière. Pour ce faire, vous devez passer le modèle d'expression régulière à un constructeur Regex. Un objet Regex est immuable ; lorsque vous instanciez un objet Regex avec une expression régulière, l'expression régulière de cet objet ne peut pas être modifiée.

  • En fournissant à la fois l'expression régulière et le texte à rechercher à une méthode Regexstatic (Shared en Visual Basic). Cela vous permet d'utiliser une expression régulière sans créer explicitement un objet Regex.

Toutes les méthodes d'identification de modèle Regex incluent des surcharges statiques et d'instance à la fois.

Le moteur des expressions régulières doit compiler un modèle particulier pour que celui-ci puisse être utilisé. Étant donné que les objets Regex sont immuables, c'est une procédure unique qui se produit lorsqu'un constructeur de classe Regex ou une méthode statique est appelé. Pour éviter de compiler une expression régulière unique à plusieurs reprises, le moteur d'expressions régulières met en cache les expressions régulières compilées utilisées dans les appels de méthode statique. En conséquence, les méthodes utilisant des critères spéciaux d'expression régulière offrent une performance comparable aux méthodes statique et d'instance.

Remarque importanteImportant

Dans le .NET Framework versions 1.0 et 1.1, toutes les expressions régulières compilées ont été mises en cache, qu'elles aient été utilisées en appels de méthode statique ou d'instance. À partir du .NET Framework 2.0, seules les expressions régulières utilisées dans les appels de méthode statique sont mises en cache.

Toutefois, la mise en cache peut compromettre les performances dans les deux cas suivants :

  • Lorsque vous utilisez des appels de méthode statique avec un grand nombre d'expressions régulières. Par défaut, le moteur d'expressions régulières met en cache les 15 dernières expressions régulières statiques. Si votre application utilise plus de 15 expressions régulières statiques, certaines expressions régulières doivent être recompilées. Pour empêcher cette recompilation, vous pouvez augmenter la propriété Regex.CacheSize.

  • Lorsque vous instanciez de nouveaux objets Regex avec les expressions régulières qui ont déjà été compilées. Par exemple, le code suivant définit une expression régulière pour rechercher des mots dupliqués dans un flux de texte. Bien que l'exemple utilise une expression régulière unique, il instancie un nouvel objet Regex pour traiter chaque ligne de texte. Cela provoque la recompilation de l'expression régulière avec chaque itération de la boucle.

    
    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    
    

    Pour empêcher la recompilation, vous devez instancier un objet Regex unique qui est accessible à tout le code qui le requiert, comme indiqué dans l'exemple réécrit suivant.

    
    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    
    

Retour sur Notes

Exécution d'opérations d'expression régulière

Si vous décidez d'instancier un objet Regex et d'appeler ses méthodes ou des méthodes statiques, la classe Regex offre les fonctionnalités de critères spéciaux suivantes :

  • Validation d'une correspondance. Vous appelez la méthode IsMatch pour déterminer si une correspondance est présente.

  • Récupération d'une correspondance unique. Vous appelez la méthode Match pour récupérer un objet Match qui représente la première correspondance dans une chaîne ou dans une partie d'une chaîne. Les correspondances suivantes peuvent être récupérées en appelant la méthode Match.NextMatch.

  • Récupération de toutes les correspondances. Vous appelez la méthode Matches pour récupérer un objet System.Text.RegularExpressions.MatchCollection qui représente toutes les correspondances trouvées dans une chaîne ou dans une partie d'une chaîne.

  • Remplacement de texte correspondant. Vous appelez la méthode Replace pour remplacer le texte correspondant. Le texte de remplacement peut également être défini par une expression régulière. De plus, quelques-unes des méthodes Replace incluent un paramètre MatchEvaluator qui vous permet de définir par programmation le texte de remplacement.

  • Création d'un tableau de chaînes formé de parties d'une chaîne d'entrée. Vous appelez la méthode Split pour fractionner une chaîne d'entrée aux positions définies par l'expression régulière.

En plus de ses méthodes utilisant des critères spéciaux, la classe Regex inclut plusieurs méthodes à usage déterminé :

  • La méthode Escape échappe tous les caractères qui peuvent être interprétés comme opérateurs d'expression régulière dans une expression régulière ou une chaîne d'entrée.

  • La méthode Unescape supprime ces caractères d'échappement.

  • La méthode CompileToAssembly crée un assembly qui contient des expressions régulières prédéfinies. Le .NET Framework contient des exemples de ces assemblys à objectifs spécifiques dans l'espace de noms System.Web.RegularExpressions.

Retour sur Notes

Définition d'une valeur de délai d'attente

Prend en charge. Net Framework un langage complet d'expression régulière qui fournit la puissance et souplesse importante dans les critères spéciaux. Toutefois, la puissance et souplesse proviennent à un coût : le risque de performances médiocres. Il est surprenant facile à créer des expressions régulières qui effectuent problème. Dans certains cas, les opérations d'expression régulière qui reposent sur la rétroaction excessive peuvent sembler cesser de répondre lorsqu'elles traitent le texte correspondant presque au modèle d'expression régulière. Pour plus d'informations sur le moteur de traitement des expressions régulières du .NET Framework, consultez Comportement détaillé des expressions régulières. Pour plus d'informations sur la rétroaction excessive, consultez Rétroaction.

Depuis le .NET Framework 4.5, vous pouvez définir un délai d'attente pour les correspondances d'expression régulière. Si le moteur des expressions régulières ne peut pas identifier une correspondance dans cet intervalle de temps, l'opération correspondante lève une exception d'RegexMatchTimeoutException. Dans la plupart des cas, cela empêché le moteur des expressions régulières de gaspiller la puissance de traitement en essayant de correspondre au texte correspondant presque au modèle d'expression régulière. Il peut également indiquer, cependant, que le délai d'attente a été si faible défini, ou que la charge d'ordinateur actuelle a provoqué une dégradation globale des performances.

La façon dont vous gérez l'exception dépend de la cause de l'exception. Si l'exception se produit car le délai d'attente est si faible défini ou en raison de charge d'ordinateur excessive, vous pouvez augmenter le délai d'attente et recommencer l'opération correspondante. Si l'exception se produit parce que l'expression régulière utilise la rétroaction excessive, vous pouvez supposer qu'une correspondance n'existe pas, et, éventuellement, vous pouvez signaler des informations qui vous aideront à modifier le modèle d'expression régulière.

Vous pouvez définir un délai d'attente en appelant le constructeur Regex(String, RegexOptions, TimeSpan) lorsque vous instanciez un objet d'expression régulière. Pour les méthodes statiques, vous pouvez définir un délai d'attente en appelant une surcharge d'une méthode correspondante qui a un paramètre matchTimeout. Si vous ne définissez pas une valeur de délai d'attente explicitement, la valeur du délai d'attente par défaut est déterminée comme suit :

  • En utilisant la valeur du délai d'attente au niveau, s'il existe. Cela peut être toute valeur du délai d'attente qui s'applique au domaine d'application dans lequel l'objet Regex est instancié ou l'appel de méthode statique est effectué. Vous pouvez définir la valeur du délai d'attente au niveau en appelant la méthode AppDomain.SetData affecte la représentation sous forme de chaîne d'une valeur d'TimeSpan à la propriété « REGEX_DEFAULT_MATCH_TIMEOUT ».

  • En utilisant la valeur InfiniteMatchTimeout, si aucune valeur du délai d'attente au niveau n'a été définie.

Remarque importanteImportant

Nous vous recommandons de défini une valeur de délai d'attente dans toutes les opérations de critères spéciaux d'expression régulière. Pour plus d'informations, consultez Meilleures pratiques des expressions régulières dans le .NET Framework.

Retour sur Notes

L'exemple de code suivant utilise une expression régulière pour vérifier les occurrences répétées de mots dans une chaîne. L'expression régulière \b(?<word>\w+)\s+(\k<word>)\b peut être interprétée comme illustré dans le tableau suivant.

Modèle

Description

\b

Démarre la correspondance à la limite d'un mot.

(?<word>\w+)

Met en correspondance un ou plusieurs caractères du mot jusqu'à la limite d'un mot. Nomme ce groupe capturé word.

\s+

Met en correspondance un ou plusieurs espaces blancs.

(\k<word>)

Met en correspondance le groupe capturé nommé word.

\b

Mettre en correspondance la limite d'un mot.


using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumped over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }

    }
	
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumped over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54


L'exemple de code suivant illustre l'utilisation d'une expression régulière pour vérifier si une chaîne représente une valeur monétaire ou a le format correct pour représenter une valeur monétaire. Dans ce cas, l'expression régulière est construite dynamiquement à partir des propriétés NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign et NumberFormatInfo.PositiveSign pour la culture actuelle de l'utilisateur. Si la culture actuelle du système est en-US, l'expression régulière résultante est ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Cette expression régulière peut être interprétée comme illustré dans le tableau suivant.

Modèle

Description

^

Démarre au début de la chaîne.

\s*

Correspond à zéro, un ou plusieurs espaces blancs.

[\+-]?

Met en correspondance zéro ou une occurrence d'un signe positif ou négatif.

\s?

Mettre en correspondance zéro ou un espace blanc.

\$?

Met en correspondance zéro ou une occurrence du signe dollar.

\s?

Mettre en correspondance zéro ou un espace blanc.

\d*

Met en correspondance zéro ou plusieurs chiffres décimaux.

\.?

Met en correspondance zéro ou un symbole de virgule décimale.

\d{2}?

Correspond zéro ou une fois à deux chiffres décimaux.

(\d*\.?\d{2}?){1}

Met en correspondance le modèle de chiffres intégraux et fractionnaires séparés par un symbole de virgule décimale au moins une fois.

$

Met en correspondance la fin de la chaîne.

Dans ce cas, l'expression régulière suppose qu'une chaîne de devise valide ne contient pas de symboles de séparateur de groupes et qu'elle n'a pas de chiffres fractionnaires ou qu'elle n'a pas le nombre de chiffres fractionnaires défini par la propriété CurrencyDecimalDigits de la culture actuelle.


using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern; 
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";

      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.


Étant donné que l'expression régulière dans cet exemple est construite dynamiquement, nous ne savons pas au moment de la conception si le symbole monétaire de la culture actuelle, le signe décimal ou les signes positif et négatif peuvent être mal interprétés par le moteur d'expressions régulières comme opérateurs du langage de l'expression régulière. Pour empêcher toute mauvaise interprétation, l'exemple passe chaque chaîne générée dynamiquement à la méthode Escape.

.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

La classe Regex est thread-safe et immuable (en lecture seule). Les objets Regex peuvent être créés sur tout thread et partagés entre les threads. Pour plus d'informations, consultez Sécurité des threads.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft