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 une chaîne d’entrée pour une sous-chaîne qui correspond à un modèle d’expression régulière et retourne la première occurrence en tant qu’objet Match unique.

Surcharges

Match(String)	Recherche la chaîne d’entrée spécifiée pour 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 la chaîne d’entrée spécifiée pour la première occurrence de l’expression régulière spécifiée.
Match(String, Int32, Int32)	Recherche la chaîne d’entrée pour 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 de caractères spécifié.
Match(String, String, RegexOptions)	Recherche la chaîne d’entrée pour la première occurrence de l’expression régulière spécifiée, à l’aide des options de correspondance spécifiées.
Match(String, String, RegexOptions, TimeSpan)	Recherche la chaîne d’entrée pour la première occurrence de l’expression régulière spécifiée, à l’aide des options de correspondance et de l’intervalle de délai d’attente spécifiés.

Match(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche la chaîne d’entrée spécifiée pour 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 à rechercher une correspondance.

Retours

Match

Objet qui contient des informations sur la correspondance.

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 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 d’expression régulière (\w+)\s+(car) correspond aux occurrences du mot « car » ainsi que le mot qui l’précède. Il est interprété comme indiqué dans le tableau suivant.

Modèle	Description
`(\w+)`	Mettre en correspondance un ou plusieurs caractères de mot. Il s’agit du premier groupe de capture.
`\s+`	Mettre en correspondance un ou plusieurs caractères d’espace blanc.
(voiture)	Mettre en correspondance la chaîne littérale « car ». Il s’agit du deuxième groupe de capture.

Remarques

La méthode Match(String) 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 générer un modèle d’expression régulière, consultez langage d’expression régulière - Informations de référence rapides.

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é Success de l’objet Match retourné. Si une correspondance est trouvée, la propriété Value de l’objet Match retournée 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 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 Match.NextMatch de l’objet Match retourné. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String).

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

NextMatch()
langage d’expression régulière - de référence rapide

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 à rechercher une correspondance.

startat: Int32

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

Retours

Match

Objet qui contient des informations sur la correspondance.

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.

Remarques

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

Voir aussi

NextMatch()
langage d’expression régulière - de référence rapide

S’applique à

Match(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche la chaîne d’entrée spécifiée pour 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 à rechercher une correspondance.

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 s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Exemples

L’exemple suivant appelle la méthode Match(String, String) pour rechercher le premier mot qui contient au moins un caractère z, puis appelle la méthode Match.NextMatch 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`	Commencez la correspondance à une limite de mot.
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères de mot.
`z+`	Mettre en correspondance une ou plusieurs occurrences du caractère `z`.
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères de mot.
`\b`	Terminez la correspondance à une limite de mot.

Remarques

La méthode Match(String, String) 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 générer un modèle d’expression régulière, consultez langage d’expression régulière - Informations de référence rapides.

La méthode Match(String, String) statique équivaut à construire un objet Regex avec le modèle d’expression régulière spécifié et à appeler l’instance Match(String) méthode. Dans ce cas, le moteur d’expression régulière met en cache le modèle 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 récupérer une correspondance de modèle est Match(String, String), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

NextMatch()
langage d’expression régulière - de référence rapide

S’applique à

Match(String, Int32, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche la chaîne d’entrée pour 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 de caractères spécifié.

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 à rechercher une correspondance.

beginning: Int32

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

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 est 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 une position qui se trouve en dehors de la plage 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.

Remarques

La méthode Match(String, Int32, Int32) 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 générer un modèle d’expression régulière, consultez langage d’expression régulière - Informations de référence rapides.

Modèle d’expression régulière pour lequel les recherches de méthode Match(String, Int32, Int32) sont définies par l’appel à l’un des constructeurs de classe Regex. Pour plus d’informations sur les éléments qui peuvent former un modèle d’expression régulière, consultez langage d’expression régulière - Informations de référence rapides.

La méthode Match(String, Int32, Int32) recherche la partie de input définie par les paramètres beginning et length pour le modèle d’expression régulière. 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 le input était effectivement input.Substring(beginning, length), sauf que l’index d’une 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’existe aucun input en dehors de cette plage. Par exemple, les ancres ^, \Get \A seront satisfaites à beginning et $ et \z seront satisfaites à beginning + length - 1.

Si la recherche passe de gauche à droite (valeur par défaut), le moteur d’expression régulière recherche du caractère à l’index beginning au 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 passe de droite à gauche, le moteur d’expression régulière effectue des recherches du caractère à l’index beginning + length - 1 au 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 Match.NextMatch de l’objet Match retourné.

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 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 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

NextMatch()
langage d’expression régulière - de référence rapide

S’applique à

Match(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche la chaîne d’entrée pour la première occurrence de l’expression régulière spécifiée, à l’aide des 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 à 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

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 de bits valide de valeurs RegexOptions.

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 définit une expression régulière qui correspond aux mots commençant par la lettre « a ». Il utilise l’option RegexOptions.IgnoreCase pour s’assurer que l’expression régulière recherche les mots commençant par un majuscule « a » et une minuscule « a ».

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`	Commencez la correspondance à une limite de mot.
`a`	Mettre en correspondance le caractère « a ».
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères de mot.
`\b`	Terminez la correspondance à une limite de mot.

Remarques

La méthode Match(String, String, RegexOptions) 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 générer un modèle d’expression régulière, consultez langage d’expression régulière - Informations de référence rapides.

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

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 NextMatch de l’objet Match retourné. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String, String, RegexOptions).

Notes pour les appelants

Voir aussi

NextMatch()
langage d’expression régulière - de référence rapide

S’applique à

Match(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Recherche la chaîne d’entrée pour la première occurrence de l’expression régulière spécifiée, à l’aide des options de correspondance et de 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 à 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

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 de bits valide de valeurs RegexOptions.

-ou-

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

RegexMatchTimeoutException

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

Remarques

La méthode Match(String, String, RegexOptions, TimeSpan) 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 générer un modèle d’expression régulière, consultez langage d’expression régulière - Informations de référence rapides.

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

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

langage d’expression régulière - de référence rapide

S’applique à

Partager via

Regex.Match Méthode

Définition

Surcharges

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)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

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