Regex.IsMatch Método

Definição

Indica se a expressão regular encontra uma correspondência na cadeia de caracteres de entrada.

Sobrecargas

IsMatch(String, String, RegexOptions, TimeSpan)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada, usando as opções de correspondência e intervalo de tempo limite especificados.

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

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado, usando as opções de correspondência especificadas e o intervalo de tempo limite.

IsMatch(String, String, RegexOptions)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado, usando as opções de correspondência especificadas.

IsMatch(String, String)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada.

IsMatch(ReadOnlySpan<Char>, String)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado.

IsMatch(ReadOnlySpan<Char>, Int32)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em um intervalo de entrada especificado.

IsMatch(String)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em uma cadeia de caracteres de entrada especificada.

IsMatch(ReadOnlySpan<Char>)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em um intervalo de entrada especificado.

IsMatch(String, Int32)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência na cadeia de caracteres de entrada especificada, começando na posição inicial especificada na cadeia de caracteres.

IsMatch(String, String, RegexOptions, TimeSpan)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada, usando as opções de correspondência e intervalo de tempo limite especificados.

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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.

pattern
String

O padrão de expressão regular para correspondência.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.

matchTimeout
TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um erro de análise da expressão regular.

input ou pattern é null.

options não é um valor RegexOptions válido.

- ou -

matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

Ocorreu um tempo limite.

Exemplos

O exemplo a seguir ilustra o uso do IsMatch(String, String, RegexOptions, TimeSpan) método para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico. A correspondência do padrão de expressão regular deve envolver a pesquisa mínima por meio da cadeia de caracteres de entrada, portanto, o método define um intervalo de tempo limite de 500 milissegundos.

using System;
using System.Text.RegularExpressions;

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

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

O padrão da expressão regular é:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.

Padrão Descrição
^ Começar a correspondência no início da cadeia de caracteres.
[A-Z0-9] Corresponder qualquer caractere alfabético único de A até Zou qualquer caractere numérico.
\d{2} Corresponde a dois caracteres numéricos.
[A-Z0-9] Corresponder qualquer caractere alfabético único de A até Zou qualquer caractere numérico.
- Corresponder a um hífen.
\d{3} Corresponde exatamente a três caracteres numéricos.
(-\d{3}){2} Localize um hífen seguido por três caracteres numéricos e corresponda a duas ocorrências desse padrão.
[A-Z0-9] Corresponder qualquer caractere alfabético único de A até Zou qualquer caractere numérico.
$ Encerrar a correspondência ao final da cadeia de caracteres.

Chamar o IsMatch(String, String, RegexOptions, TimeSpan) método com o options parâmetro definido como RegexOptions.IgnoreCase é equivalente a definir a seguinte expressão regular:

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

Para comparação, consulte o exemplo do IsMatch(String, String) método .

Comentários

O IsMatch método normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e, em seguida, recuperá-las para manipulação subsequente, chame o Match método ou Matches .

O método estático IsMatch(String, String, RegexOptions, TimeSpan) é equivalente a construir um Regex objeto com o padrão de expressão regular especificado por pattern e as opções de expressão regular especificadas por options e chamando o método de IsMatch(String) instância. Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo de expressão regular.

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte Expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

O matchTimeout parâmetro especifica por quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de atingir o tempo limite. Definir um intervalo de tempo limite impede que expressões regulares que dependem de retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas. Para obter mais informações, consulte Práticas recomendadas para expressões regulares e retrocesso. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método gerará uma RegexMatchTimeoutException exceção. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.

Notas aos Chamadores

Recomendamos que você defina o matchTimeout parâmetro como um valor apropriado, como dois segundos. Se você desabilitar tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressões regulares oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite apenas nas seguintes condições:

  • Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.

  • Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule correspondências, não correspondências e correspondências próximas com eficiência.

  • Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.

Confira também

Aplica-se a

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

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado, usando as opções de correspondência especificadas e o intervalo de tempo limite.

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

Parâmetros

input
ReadOnlySpan<Char>

O intervalo para pesquisar uma correspondência.

pattern
String

O padrão de expressão regular para correspondência.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.

matchTimeout
TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um erro de análise da expressão regular.

pattern é null

Ocorreu um tempo limite.

options não está em um valor válido RegexOptions ou matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

Aplica-se a

IsMatch(String, String, RegexOptions)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada, usando as opções de correspondência especificadas.

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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.

pattern
String

O padrão de expressão regular para correspondência.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um erro de análise da expressão regular.

input ou pattern é null.

options não é um valor RegexOptions válido.

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir ilustra o uso do IsMatch(String, String) método para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

using System;
using System.Text.RegularExpressions;

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

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

O padrão da expressão regular é:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.

Padrão Descrição
^ Começar a correspondência no início da cadeia de caracteres.
[A-Z0-9] Corresponder qualquer caractere alfabético único de A até Zou qualquer caractere numérico.
\d{2} Corresponde a dois caracteres numéricos.
[A-Z0-9] Corresponder qualquer caractere alfabético único de A até Zou qualquer caractere numérico.
- Corresponder a um hífen.
\d{3} Corresponde exatamente a três caracteres numéricos.
(-\d{3}){2} Localize um hífen seguido por três caracteres numéricos e corresponda a duas ocorrências desse padrão.
[A-Z0-9] Corresponder qualquer caractere alfabético único de A até Zou qualquer caractere numérico.
$ Encerrar a correspondência ao final da cadeia de caracteres.

Chamar o IsMatch(String, String, RegexOptions) método com o options parâmetro definido como RegexOptions.IgnoreCase é equivalente a definir a seguinte expressão regular:

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

Para comparação, consulte o exemplo do IsMatch(String, String) método .

Comentários

O IsMatch método normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e, em seguida, recuperá-las para manipulação subsequente, chame o Match método ou Matches .

O método estático IsMatch(String, String, RegexOptions) é equivalente a construir um Regex objeto com o padrão de expressão regular especificado por pattern e as opções de expressão regular especificadas por options e chamando o método de IsMatch(String) instância. Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo de expressão regular.

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte Expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede que o método atinja o tempo limite, será usado. O método estático recomendado para verificar uma correspondência de padrão é IsMatch(String, String, RegexOptions, TimeSpan), que permite definir o intervalo de tempo limite.

Confira também

Aplica-se a

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado, usando as opções de correspondência especificadas.

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

Parâmetros

input
ReadOnlySpan<Char>

O intervalo para pesquisar uma correspondência.

pattern
String

O padrão de expressão regular para correspondência.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um erro de análise da expressão regular.

pattern é null

Ocorreu um tempo limite.

options não está em um valor válido RegexOptions .

Aplica-se a

IsMatch(String, String)

Indica se a expressão regular especificada encontra uma correspondência na cadeia de caracteres de entrada especificada.

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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.

pattern
String

O padrão de expressão regular para correspondência.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um erro de análise da expressão regular.

input ou pattern é null.

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir ilustra o uso do IsMatch(String, String) método para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

using System;
using System.Text.RegularExpressions;

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

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

O padrão da expressão regular é:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.

Padrão Descrição
^ Inicie a correspondência no início da linha.
[a-zA-Z0-9] Corresponde a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
\d{2} Corresponde a dois caracteres numéricos.
[a-zA-Z0-9] Corresponde a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
- Corresponder a um hífen.
\d{3} Corresponde exatamente a três caracteres numéricos.
(-\d{3}){2} Localize um hífen seguido por três caracteres numéricos e corresponda a duas ocorrências desse padrão.
[a-zA-Z0-9] Corresponde a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
$ Encerre a correspondência no final da linha.

Comentários

O IsMatch método normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e, em seguida, recuperá-las para manipulação subsequente, chame o Match método ou Matches .

O método estático IsMatch(String, String) é equivalente a construir um Regex objeto com o padrão de expressão regular especificado por pattern e chamar o método de IsMatch(String) instância. Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo de expressão regular.

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a ser correspondida. Para obter mais informações sobre expressões regulares, consulte Expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual o método é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede que o método atinja o tempo limite, será usado. O método estático recomendado para verificar uma correspondência de padrão é IsMatch(String, String, RegexOptions, TimeSpan), que permite definir o intervalo de tempo limite.

Confira também

Aplica-se a

IsMatch(ReadOnlySpan<Char>, String)

Indica se a expressão regular especificada encontra uma correspondência no intervalo de entrada especificado.

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

Parâmetros

input
ReadOnlySpan<Char>

O intervalo para pesquisar uma correspondência.

pattern
String

O padrão de expressão regular para correspondência.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um erro de análise da expressão regular.

pattern é null

Ocorreu um tempo limite.

Aplica-se a

IsMatch(ReadOnlySpan<Char>, Int32)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em um intervalo de entrada especificado.

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

Parâmetros

input
ReadOnlySpan<Char>

O intervalo para pesquisar uma correspondência.

startat
Int32

A posição do caractere baseada em zero na qual iniciar a pesquisa.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um tempo limite.

Aplica-se a

IsMatch(String)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em uma cadeia de caracteres de entrada especificada.

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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

input é null.

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir ilustra o uso do IsMatch(String) método para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

using System;
using System.Text.RegularExpressions;

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

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

O padrão da expressão regular é:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.

Padrão Descrição
^ Inicie a correspondência no início da linha.
[a-zA-Z0-9] Corresponde a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
\d{2} Corresponde a dois caracteres numéricos.
[a-zA-Z0-9] Corresponde a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
- Corresponder a um hífen.
\d{3} Corresponde exatamente a três caracteres numéricos.
(-\d{3}){2} Localize um hífen seguido por três caracteres numéricos e corresponda a duas ocorrências desse padrão.
[a-zA-Z0-9] Corresponder a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
$ Encerre a correspondência no final da linha.

Comentários

O IsMatch método normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e, em seguida, recuperá-las para manipulação subsequente, chame o Match método ou Matches .

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação correspondente exceder o intervalo de tempo limite especificado pelo Regex.Regex(String, RegexOptions, TimeSpan) construtor. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o Regex objeto é criado. Se nenhum tempo limite for definido na chamada do Regex construtor ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.

Confira também

Aplica-se a

IsMatch(ReadOnlySpan<Char>)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em um intervalo de entrada especificado.

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

Parâmetros

input
ReadOnlySpan<Char>

O intervalo para pesquisar uma correspondência.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Ocorreu um tempo limite.

Aplica-se a

IsMatch(String, Int32)

Indica se a expressão regular especificada no construtor Regex encontra uma correspondência na cadeia de caracteres de entrada especificada, começando na posição inicial especificada na cadeia de caracteres.

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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.

startat
Int32

A posição do caractere em que a pesquisa será iniciada.

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

input é null.

startat é menor que zero ou maior que o tamanho de input.

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir ilustra o uso do IsMatch(String, Int32) método para determinar se uma cadeia de caracteres é um número de parte válido. Ele procura um número de parte que segue dois-pontos (:) caractere em uma cadeia de caracteres. O IndexOf(Char) método é usado para determinar a posição do caractere de dois-pontos, que é então passado para o IsMatch(String, Int32) método . A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

using System;
using System.Text.RegularExpressions;

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

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

O padrão da expressão regular é:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.

Padrão Descrição
[a-zA-Z0-9] Corresponder a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
\d{2} Corresponde a dois caracteres numéricos.
[a-zA-Z0-9] Corresponder a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
- Corresponder a um hífen.
\d{3} Corresponde exatamente a três caracteres numéricos.
(-\d{3}){2} Localize um hífen seguido por três caracteres numéricos e corresponda a duas ocorrências desse padrão.
[a-zA-Z0-9] Corresponder a um único caractere alfabético (a por meio z de ou A por Z) ou caractere numérico.
$ Encerre a correspondência no final da linha.

Comentários

O IsMatch método normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e, em seguida, recuperá-las para manipulação subsequente, chame o Match método ou Matches .

Para obter mais detalhes sobre startat, consulte a seção Comentários de Match(String, Int32).

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação correspondente exceder o intervalo de tempo limite especificado pelo Regex.Regex(String, RegexOptions, TimeSpan) construtor. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o Regex objeto é criado. Se nenhum tempo limite for definido na chamada do Regex construtor ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.

Confira também

Aplica-se a