Regex.Match Méthode

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Recherche dans une chaîne d'entrée une sous-chaîne qui correspond à un modèle d'expression régulière et retourne la première occurrence sous forme d'objet Match unique.

Surcharges

Match(String, String, RegexOptions)	Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance spécifiées.
Match(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.
Match(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.
Match(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.
Match(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.
Match(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, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.

Match(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance spécifiées.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Paramètres

input: String

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

pattern: String

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

options: RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

Retours

Match

Objet qui contient des informations sur la correspondance.

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 combinaison d’opérations au niveau du bit de valeurs RegexOptions.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant définit une expression régulière qui correspond à des mots commençant par la lettre « a ». Il utilise l’option RegexOptions.IgnoreCase pour s’assurer que l’expression régulière localise les mots commençant par un « a » majuscule et un « a » minuscule.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        public static void Main()
        {
            string pattern = @"\ba\w*\b";
            string input = "An extraordinary day dawns with each new day.";
            Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            if (m.Success)
                Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
        }
    }
}

// The example displays the following output:
//        Found 'An' at position 0.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

Le modèle d'expression régulière \ba\w*\b est interprété comme indiqué dans le tableau suivant.

Modèle	Description
`\b`	Commencer la correspondance à la limite d'un mot.
`a`	Faire correspondre le caractère « a ».
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères de mots.
`\b`	Terminer la correspondance à la limite d'un mot.

Remarques

La Match(String, String, RegexOptions) méthode retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La méthode statique Match(String, String, RegexOptions) équivaut à construire un Regex objet avec le Regex(String, RegexOptions) constructeur et à appeler la méthode instanceMatch(String).

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.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de Value l’objet retourné Match contient la sous-chaîne de input qui correspond au modèle d’expression régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

Cette méthode retourne la première sous-chaîne trouvée dans input qui correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de l’objet NextMatch retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la Regex.Matches(String, String, RegexOptions) méthode .

L’exception RegexMatchTimeoutException est levée si la durée 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 du 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 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 une correspondance de modèle est Match(String, String), qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Match(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

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.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);

public System.Text.RegularExpressions.Match Match (string input);

member this.Match : string -> System.Text.RegularExpressions.Match

Public Function Match (input As String) As Match

Paramètres

input: String

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

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

ArgumentNullException

input a la valeur null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant recherche des correspondances de modèle d’expression régulière dans une chaîne, puis répertorie les groupes, captures et positions de capture correspondants.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

using System;
using System.Text.RegularExpressions;

class Example
{
   static void Main()
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);

      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success)
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++)
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++)
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Le modèle (\w+)\s+(car) d’expression régulière correspond aux occurrences du mot « car » avec le mot qui le précède. Elle est interprétée comme indiqué dans le tableau suivant.

Modèle	Description
`(\w+)`	Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du premier groupe de capture.
`\s+`	Mettre en correspondance un ou plusieurs espaces blancs.
(voiture)	Faire correspondre la chaîne littérale « car ». Il s'agit du deuxième groupe de capture.

Remarques

La Match(String) méthode retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

Cette méthode retourne la première sous-chaîne de input qui correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de l’objet Match.NextMatch retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la Regex.Matches(String) méthode .

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur. 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 Regex de constructeur ou dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Voir aussi

S’applique à

Match(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

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.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);

public System.Text.RegularExpressions.Match Match (string input, int startat);

member this.Match : string * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, startat As Integer) As Match

Paramètres

input: String

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

startat: Int32

Position du caractère de base zéro à partir duquel commencer la recherche.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

ArgumentNullException

input a la valeur null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

Pour plus d’informations sur cette API, consultez Remarques supplémentaires sur l’API pour Regex.Match.

Voir aussi

S’applique à

Match(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.Match Match (string input, string pattern);

static member Match : string * string -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String) As Match

Paramètres

input: String

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

pattern: String

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

Retours

Match

Objet qui contient des informations sur la correspondance.

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 a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant appelle la Match(String, String) méthode pour rechercher le premier mot qui contient au moins un z caractère, puis appelle la Match.NextMatch méthode pour rechercher des correspondances supplémentaires.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example
    {
        public static void Main()
        {
            string input = "ablaze beagle choral dozen elementary fanatic " +
                           "glaze hunger inept jazz kitchen lemon minus " +
                           "night optical pizza quiz restoration stamina " +
                           "train unrest vertical whiz xray yellow zealous";
            string pattern = @"\b\w*z+\w*\b";
            Match m = Regex.Match(input, pattern);
            while (m.Success)
            {
                Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
                m = m.NextMatch();
            }
        }
    }
}

// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

Le modèle d'expression régulière \b\w*z+\w*\b est interprété comme indiqué dans le tableau suivant.

Modèle	Description
`\b`	Commencer la correspondance à la limite d'un mot.
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères de mots.
`z+`	Mettre en correspondance un ou plusieurs occurrences de la `z` caractère.
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères de mots.
`\b`	Terminer la correspondance à la limite d'un mot.

Remarques

La Match(String, String) méthode retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La méthode statique Match(String, String) équivaut à construire un Regex objet avec le modèle d’expression régulière spécifié et à appeler la méthode instanceMatch(String). Dans ce cas, le moteur d’expression régulière met en cache le modèle d’expression régulière.

Notes pour les appelants

Voir aussi

S’applique à

Match(String, Int32, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

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.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);

public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);

member this.Match : string * int * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Paramètres

input: String

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

beginning: Int32

Position du caractère de base zéro dans la chaîne d'entrée qui définit la position la plus à gauche à parcourir.

length: Int32

Nombre de caractères dans la sous-chaîne à inclure dans la recherche.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

ArgumentNullException

input a la valeur null.

ArgumentOutOfRangeException

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

- ou -

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

- ou -

beginning+length-1 identifie un emplacement situé en dehors de la plage de input.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

La Match(String, Int32, Int32) méthode retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une partie d’une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

Le modèle d’expression régulière pour lequel la Match(String, Int32, 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.

La Match(String, Int32, Int32) méthode recherche le modèle d’expression régulière dans la partie de input définie par les beginning paramètres et length . beginning définit toujours l’index du caractère le plus à gauche à inclure dans la recherche et length définit le nombre maximal de caractères à rechercher. Ensemble, ils définissent la plage de la recherche. Le comportement est exactement comme si était input effectivement input.Substring(beginning, length), sauf que l’index de toute correspondance est compté par rapport au début de input. Cela signifie que toutes les ancres ou assertions de largeur nulle au début ou à la fin du modèle se comportent comme s’il n’y avait pas input en dehors de cette plage. Par exemple, les ancres , \Get seront satisfaits ^à beginning et $ seront \z satisfaits à beginning + length - 1\A .

Si la recherche se poursuit de gauche à droite (valeur par défaut), le moteur d’expression régulière effectue une recherche à partir du caractère au niveau de l’index beginning vers le caractère à l’index beginning + length - 1. Si le moteur d’expression régulière a été instancié à l’aide de l’option RegexOptions.RightToLeft afin que la recherche se poursuive de droite à gauche, le moteur d’expression régulière effectue une recherche à partir du caractère au niveau de l’index beginning + length - 1 vers le caractère à l’index beginning.

Cette méthode retourne la première correspondance qu’elle trouve dans cette plage. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de l’objet Match.NextMatch retournéMatch.

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur. Si vous ne définissez pas de valeur 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 Regex de constructeur ou dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Voir aussi

S’applique à

Match(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

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

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Paramètres

input: String

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

pattern: String

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

options: RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

matchTimeout: TimeSpan

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

Retours

Match

Objet qui contient des informations sur la correspondance.

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 combinaison d’opérations au niveau du bit de valeurs RegexOptions.

- ou -

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

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

La Match(String, String, RegexOptions, TimeSpan) méthode retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La méthode statique Match(String, String, RegexOptions, TimeSpan) équivaut à construire un Regex objet avec le Regex(String, RegexOptions, TimeSpan) constructeur et à appeler la méthode instanceMatch(String).

Le matchTimeout paramètre spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant son expiration. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui reposent sur un retour arrière excessif de s’arrêter de répondre lorsqu’elles traitent des entrées qui contiennent des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et la rétroaction. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une RegexMatchTimeoutException exception. 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 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

Langage des expressions régulières - Aide-mémoire

S’applique à

Regex.Match Méthode

Définition

Surcharges

Match(String, String, RegexOptions)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Match(String)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Match(String, Int32)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

Match(String, String)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Match(String, Int32, Int32)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

Match(String, String, RegexOptions, TimeSpan)

Paramètres

Retours

Exceptions

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires