Regex, classe

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

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

[SerializableAttribute] 
public class Regex : ISerializable
/** @attribute SerializableAttribute() */ 
public class Regex implements ISerializable
SerializableAttribute 
public class Regex implements ISerializable

La classe Regex contient plusieurs méthodes statiques qui vous permettent d'utiliser une expression régulière sans explicitement créer un objet Regex. L'utilisation d'une méthode statique équivaut à construire un objet Regex, à l'utiliser une fois puis à le jeter.

La classe Regex est immuable (en lecture seule) et est thread-safe, de façon inhérente. Il est possible de créer les objets Regex sur n'importe quel thread et de les partager entre les threads. Pour plus d'informations, consultez Sécurité des threads.

L'exemple de code suivant illustre l'utilisation d'une expression régulière pour vérifier si une chaîne a le format correct pour représenter une valeur monétaire. Notez l'utilisation des jetons ^ et $ englobants pour indiquer que la chaîne entière, pas seulement une sous-chaîne, doit correspondre à l'expression régulière.

using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

    	  // Define a regular expression for currency values.
  	    Regex rx = new Regex(@"^-?\d+(\.\d{2})?$");
  	    
  	    // Define some test strings.
  	    string[] tests = {"-42", "19.99", "0.001", "100 USD"};
  	    
  	    // Check each test string against the regular expression.
  	    foreach (string test in tests)
  	    {
  	        if (rx.IsMatch(test))
  	        {
  	            Console.WriteLine("{0} is a currency value.", test);
  	        }
  	        else
  	        {
  	            Console.WriteLine("{0} is not a currency value.", test);
  	        }
  	    }
  	   
    }	
	
}

import System.*;
import System.Text.RegularExpressions.*;

public class Test
{
    public static void main(String[] args)
    {
        // Define a regular expression for currency values.
        Regex rx = new Regex("^-?\\d+(\\.\\d{2})?$");

        // Define some test strings.
        String tests[] =  { "-42", "19.99", "0.001", "100 USD" };

        // Check each test string against the regular expression.
        for (int iCtr = 0; iCtr < tests.get_Length(); iCtr++) {
            String test = (String)tests.get_Item(iCtr);
            if (rx.IsMatch(test)) {
                Console.WriteLine("{0} is a currency value.", test);
            }
            else {
                Console.WriteLine("{0} is not a currency value.", test);
            }
        }
    } //main 
} //Test

L'exemple de code suivant illustre l'utilisation d'une expression régulière pour vérifier les occurrences répétées de mots dans une chaîne. Notez l'utilisation de la construction (?<word>) pour nommer un groupe et l'utilisation de la construction (\k<word>) pour faire référence à ce groupe plus loin dans l'expression.

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.", matches.Count);

        // Report on each match.
        foreach (Match match in matches)
        {
            string word = match.Groups["word"].Value;
            int index = match.Index;
            Console.WriteLine("{0} repeated at position {1}", word, index);   
        }
        
    }
	
}

import System.*;
import System.Text.RegularExpressions.*;

public class Test
{
    public static void main(String[] args)
    {
        // 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.", (Int32)matches.get_Count());

        // Report on each match.
        for (int iCtr = 0; iCtr < matches.get_Count(); iCtr++) {
            Match match = matches.get_Item(iCtr);
            String word = match.get_Groups().get_Item("word").get_Value();
            int index = match.get_Index();
            Console.WriteLine("{0} repeated at position {1}", word, 
                (Int32)index);
        }
    } //main       
} //Test

System.Object
  System.Text.RegularExpressions.Regex
     Classes dérivées

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

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

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0

Ajouts de la communauté

AJOUTER
Afficher: