Regex.IsMatch Método

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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 especificadas e o intervalo de tempo limite.
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>, Int32)	Indica se a expressão regular especificada no construtor Regex encontra uma correspondência em um intervalo de entrada especificado.
IsMatch(ReadOnlySpan<Char>, String)	Indica se a expressão regular especificada encontra uma correspondência no 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)	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, String, RegexOptions, TimeSpan)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 e o intervalo de tempo limite.

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

options: RegexOptions

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

matchTimeout: TimeSpan

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

Retornos

Boolean

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

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

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

-ou-

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

RegexMatchTimeoutException

Ocorreu um tempo limite.

Exemplos

O exemplo a seguir ilustra o uso do método IsMatch(String, String, RegexOptions, TimeSpan) 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 pesquisa mínima por meio da cadeia de caracteres de entrada, de modo que o método define um intervalo de tempo limite de 500 milissegundos.

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
    {
        bool isMatch = Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(500));
        Console.WriteLine($"{partNumber} {(isMatch ? "is" : "is not")} a valid part number.");
    }
    catch (RegexMatchTimeoutException e)
    {
        Console.WriteLine($"Timeout after {e.MatchTimeout} seconds matching {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 de 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 de expressão regular é interpretado.

Padrão	Descrição
`^`	Inicie a correspondência no início da cadeia de caracteres.
`[A-Z0-9]`	Corresponda a qualquer caractere alfabético único de `A` até `Z`ou qualquer caractere numérico.
`\d{2}`	Corresponde a dois caracteres numéricos.
`[A-Z0-9]`	Corresponda a qualquer caractere alfabético único de `A` até `Z`ou qualquer caractere numérico.
`-`	Corresponde a um hífen.
`\d{3}`	Corresponde a exatamente 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]`	Corresponda a qualquer caractere alfabético único de `A` até `Z`ou qualquer caractere numérico.
`$`	Encerre a correspondência no final da cadeia de caracteres.

Chamar o método IsMatch(String, String, RegexOptions, TimeSpan) com o parâmetro options 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 método IsMatch(String, String).

Comentários

O método IsMatch 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 recuperá-las para manipulação subsequente, chame o método Match ou Matches.

O método de IsMatch(String, String, RegexOptions, TimeSpan) estático é equivalente à construção de um objeto Regex 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 instância IsMatch(String). Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo de expressão regular.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. 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 parâmetro matchTimeout 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. A configuração de um intervalo de tempo limite impede que expressões regulares que dependem do 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 backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método gerará uma exceção RegexMatchTimeoutException. 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 parâmetro matchTimeout como um valor apropriado, como dois segundos. Se você desabilitar o tempo limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular 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 com eficiência correspondências, não correspondências e correspondências próximas.
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

elementos de linguagem de expressão regular

Aplica-se a

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

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 procurar uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

options: RegexOptions

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

matchTimeout: TimeSpan

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

Retornos

Boolean

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

Exceções

ArgumentException

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

ArgumentNullException

pattern está null

RegexMatchTimeoutException

Ocorreu um tempo limite.

ArgumentOutOfRangeException

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

Aplica-se a

IsMatch(String, String, RegexOptions)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

options: RegexOptions

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

Retornos

Boolean

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

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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 método IsMatch(String, String) 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.

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 de 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 de expressão regular é interpretado.

Padrão	Descrição
`^`	Inicie a correspondência no início da cadeia de caracteres.
`[A-Z0-9]`	Corresponda a qualquer caractere alfabético único de `A` até `Z`ou qualquer caractere numérico.
`\d{2}`	Corresponde a dois caracteres numéricos.
`[A-Z0-9]`	Corresponda a qualquer caractere alfabético único de `A` até `Z`ou qualquer caractere numérico.
`-`	Corresponde a um hífen.
`\d{3}`	Corresponde a exatamente 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]`	Corresponda a qualquer caractere alfabético único de `A` até `Z`ou qualquer caractere numérico.
`$`	Encerre a correspondência no final da cadeia de caracteres.

Chamar o método IsMatch(String, String, RegexOptions) com o parâmetro options 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 método IsMatch(String, String).

Comentários

O método de IsMatch(String, String, RegexOptions) estático é equivalente à construção de um objeto Regex 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 instância IsMatch(String). Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo de expressão regular.

A exceção RegexMatchTimeoutException 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 o tempo limite do método, será usado. O método estático recomendado para verificar se uma correspondência de padrão é IsMatch(String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

elementos de linguagem de expressão regular

Aplica-se a

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 procurar uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

options: RegexOptions

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

Retornos

Boolean

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

Exceções

ArgumentException

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

ArgumentNullException

pattern está null

RegexMatchTimeoutException

Ocorreu um tempo limite.

ArgumentOutOfRangeException

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

Aplica-se a

IsMatch(String, String)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

Retornos

Boolean

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

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

RegexMatchTimeoutException

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

Exemplos

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($"{partNumber} {(Regex.IsMatch(partNumber, pattern) ? "is" : "is not")} " +
        $"a valid part number.");

// 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 de 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 de expressão regular é interpretado.

Padrão	Descrição
`^`	Inicie a correspondência no início da linha.
`[a-zA-Z0-9]`	Corresponder a um único caractere alfabético (`a` por `z` 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 `z` ou `A` por `Z`) ou caractere numérico.
`-`	Corresponde a um hífen.
`\d{3}`	Corresponde a exatamente 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 `z` ou `A` por `Z`) ou caractere numérico.
`$`	Encerre a correspondência no final da linha.

Comentários

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

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 o tempo limite do método, será usado. O método estático recomendado para verificar se uma correspondência de padrão é IsMatch(String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

elementos de linguagem de expressão regular

Aplica-se a

IsMatch(ReadOnlySpan<Char>, Int32)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 procurar uma correspondência.

startat: Int32

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

Retornos

Boolean

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

Exceções

RegexMatchTimeoutException

Ocorreu um tempo limite.

Aplica-se a

IsMatch(ReadOnlySpan<Char>, String)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 procurar uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

Retornos

Boolean

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

Exceções

ArgumentException

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

ArgumentNullException

pattern está null

RegexMatchTimeoutException

Ocorreu um tempo limite.

Aplica-se a

IsMatch(String, Int32)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 a ser pesquisada por uma correspondência.

startat: Int32

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

Retornos

Boolean

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

Exceções

ArgumentNullException

input é null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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 método IsMatch(String, Int32) 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 método IndexOf(Char) é usado para determinar a posição do caractere de dois-pontos, que é então passado para o método IsMatch(String, Int32). 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.

string[] partNumbers = [ "Part Number: 1298-673-4192", "Part No: A08Z-931-468A",
                      "_A90-123-129X", "123K-000-1230",
                      "SKU: 0919-2893-1256" ];
Regex rgx = MyRegex();
foreach (string partNumber in partNumbers)
{
    int start = partNumber.IndexOf(':');
    if (start >= 0)
    {
        Console.WriteLine($"{partNumber} {(rgx.IsMatch(partNumber, start) ? "is" : "is not")} a valid part number.");
    }
    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 de 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 de expressão regular é interpretado.

Padrão	Descrição
`[a-zA-Z0-9]`	Corresponder a um único caractere alfabético (`a` por `z` 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 `z` ou `A` por `Z`) ou caractere numérico.
`-`	Corresponde a um hífen.
`\d{3}`	Corresponde a exatamente 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 `z` ou `A` por `Z`) ou caractere numérico.
`$`	Encerre a correspondência no final da linha.

Comentários

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

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). 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 objeto Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex 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

elementos de linguagem de expressão regular

Aplica-se a

IsMatch(String)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 a ser pesquisada por uma correspondência.

Retornos

Boolean

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

Exceções

ArgumentNullException

input é null.

RegexMatchTimeoutException

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 método IsMatch(String) 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.

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($"{partNumber} {(rgx.IsMatch(partNumber) ? "is" : "is not")} a valid part number.");

// 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 de 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 de expressão regular é interpretado.

Padrão	Descrição
`^`	Inicie a correspondência no início da linha.
`[a-zA-Z0-9]`	Corresponder a um único caractere alfabético (`a` por `z` 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 `z` ou `A` por `Z`) ou caractere numérico.
`-`	Corresponde a um hífen.
`\d{3}`	Corresponde a exatamente 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 `z` ou `A` por `Z`) ou caractere numérico.
`$`	Encerre a correspondência no final da linha.

Comentários

Confira também

elementos de linguagem de expressão regular

Aplica-se a

IsMatch(ReadOnlySpan<Char>)

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

Origem:: Regex.Match.cs

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 procurar uma correspondência.

Retornos

Boolean

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

Exceções

RegexMatchTimeoutException

Ocorreu um tempo limite.

Aplica-se a

Compartilhar via

Regex.IsMatch Método

Definição

Sobrecargas

IsMatch(String, String, RegexOptions, TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

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

Parâmetros

Retornos

Exceções

Aplica-se a

IsMatch(String, String, RegexOptions)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Parâmetros

Retornos

Exceções

Aplica-se a

IsMatch(String, String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

IsMatch(ReadOnlySpan<Char>, Int32)

Parâmetros

Retornos

Exceções

Aplica-se a

IsMatch(ReadOnlySpan<Char>, String)

Parâmetros

Retornos

Exceções

Aplica-se a

IsMatch(String, Int32)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

IsMatch(String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

IsMatch(ReadOnlySpan<Char>)

Parâmetros

Retornos

Exceções

Aplica-se a

Recursos adicionais