Regex.Match 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.

Pesquisa em uma cadeia de caracteres de entrada uma subcadeia de caracteres que corresponde a um padrão de expressão regular e retorna a primeira ocorrência como um único objeto Match.

Sobrecargas

Match(String, String, RegexOptions)	Procura a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções especificadas de correspondência.
Match(String)	Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada no construtor Regex.
Match(String, Int32)	Procura a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.
Match(String, String)	Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada.
Match(String, Int32, Int32)	Pesquisa a primeira ocorrência de uma expressão regular na cadeia de entrada, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres.
Match(String, String, RegexOptions, TimeSpan)	Pesquisa a cadeia de caracteres de entrada da primeira ocorrência da expressão regular especificada, usando as opções de correspondência e intervalo de tempo limite especificados.

Match(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Procura a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções especificadas de correspondência.

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

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

Match

Um objeto que contém informações sobre a correspondência.

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores de RegexOptions.

RegexMatchTimeoutException

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

Exemplos

O exemplo a seguir define uma expressão regular que corresponde às palavras que começam com a letra "a". Ele usa a opção RegexOptions.IgnoreCase para garantir que a expressão regular localize palavras começando com um "a" maiúsculo e um "a" minúsculo.

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.

O padrão da expressão regular \ba\w*\b é interpretado conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`a`	Corresponda ao caractere "a".
`\w*`	Corresponder a zero, um ou mais caracteres de palavra.
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Match(String, String, RegexOptions) método retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

O método estático Match(String, String, RegexOptions) é equivalente à construção de um Regex objeto com o Regex(String, RegexOptions) construtor e à chamada do método de instância Match(String) .

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.

Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade do Success objeto retornadoMatch. Se uma correspondência for encontrada, a propriedade do Value objeto retornado Match conterá a subcadeia de caracteres que corresponde ao padrão de input expressão regular. Se nenhuma correspondência for encontrada, seu valor será String.Empty.

Esse método retorna a primeira subcadeia de caracteres encontrada em input que corresponde ao padrão de expressão regular. Você pode recuperar correspondências subsequentes chamando repetidamente o método do NextMatch objeto retornadoMatch. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o Regex.Matches(String, String, RegexOptions) método .

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação correspondente 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 recuperar uma correspondência de padrão é Match(String, String), que permite definir o intervalo de tempo limite.

Confira também

Aplica-se a

Match(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada no construtor 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

Parâmetros

input: String

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

Retornos

Match

Um objeto que contém informações sobre a correspondência.

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 localiza correspondências de padrão de expressão regular em uma cadeia de caracteres e, em seguida, lista os grupos, capturas e posições de captura correspondentes.

#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

O padrão (\w+)\s+(car) de expressão regular corresponde às ocorrências da palavra "carro" junto com a palavra que a precede. Ele é interpretado conforme mostrado na tabela a seguir.

Padrão	Descrição
`(\w+)`	Fazer a correspondência a um ou mais caracteres de palavra. Este é o primeiro grupo de captura.
`\s+`	Corresponde a um ou mais caracteres de espaço em branco.
(carro)	Corresponda à cadeia de caracteres literal "car". Este é o segundo grupo de captura.

Comentários

O Match(String) método retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

Esse método retorna a primeira subcadeia de caracteres em input que corresponde ao padrão de expressão regular. Você pode recuperar correspondências subsequentes chamando repetidamente o método do Match.NextMatch objeto retornadoMatch. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o Regex.Matches(String) método .

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

Match(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Procura a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.

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

Parâmetros

input: String

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

startat: Int32

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

Retornos

Match

Um objeto que contém informações sobre a correspondência.

Exceções

ArgumentNullException

input é null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Comentários

Para obter mais informações sobre essa API, consulte Comentários de API complementares para Regex.Match.

Confira também

Aplica-se a

Match(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada.

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

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

Match

Um objeto que contém informações sobre a correspondência.

Exceções

ArgumentException

Ocorreu um erro de análise da 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

O exemplo a seguir chama o Match(String, String) método para localizar a primeira palavra que contém pelo menos um z caractere e, em seguida, chama o Match.NextMatch método para localizar quaisquer correspondências adicionais.

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

O padrão da expressão regular \b\w*z+\w*\b é interpretado conforme mostrado na tabela a seguir.

Padrão	Descrição
`\b`	Começar a correspondência em um limite de palavra.
`\w*`	Corresponder a zero, um ou mais caracteres de palavra.
`z+`	Corresponde a uma ou mais ocorrências do `z` caractere.
`\w*`	Corresponder a zero, um ou mais caracteres de palavra.
`\b`	Termina a correspondência em um limite de palavra.

Comentários

O Match(String, String) método retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

O método estático Match(String, String) é equivalente a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método de instância Match(String) . Nesse caso, o mecanismo de expressão regular armazena em cache o padrão de expressão regular.

Notas aos Chamadores

Confira também

Aplica-se a

Match(String, Int32, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Pesquisa a primeira ocorrência de uma expressão regular na cadeia de entrada, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres.

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

Parâmetros

input: String

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

beginning: Int32

A posição do caractere baseado em zero na cadeia de caracteres de entrada que define a posição mais à esquerda a ser pesquisada.

length: Int32

O número de caracteres na subcadeia de caracteres a ser incluído na pesquisa.

Retornos

Match

Um objeto que contém informações sobre a correspondência.

Exceções

ArgumentNullException

input é null.

ArgumentOutOfRangeException

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

- ou -

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

- ou -

beginning+length-1 identifica uma posição fora do intervalo de input.

RegexMatchTimeoutException

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

Comentários

O Match(String, Int32, Int32) método retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma parte de uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

O padrão de expressão regular para o qual o Match(String, Int32, Int32) método pesquisa é definido pela chamada para um dos construtores de Regex classe. Para obter mais informações sobre os elementos que podem formar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

O Match(String, Int32, Int32) método pesquisa a parte de input definida pelos beginning parâmetros e length para o padrão de expressão regular. beginning sempre define o índice do caractere mais à esquerda a ser incluído na pesquisa e length define o número máximo de caracteres a serem pesquisados. Juntos, eles definem o intervalo da pesquisa. O comportamento é exatamente como se o input fosse efetivamente input.Substring(beginning, length), exceto que o índice de qualquer correspondência é contado em relação ao início de input. Isso significa que todas as âncoras ou asserções de largura zero no início ou no final do padrão se comportam como se não houvesse nenhum input fora desse intervalo. Por exemplo, as âncoras ^, \Ge \A serão atendidas em beginning e $ e \z serão atendidas em beginning + length - 1.

Se a pesquisa continuar da esquerda para a direita (o padrão), o mecanismo de expressão regular pesquisa do caractere no índice beginning para o caractere no índice beginning + length - 1. Se o mecanismo de expressão regular foi instanciado usando a opção RegexOptions.RightToLeft para que a pesquisa prossiga da direita para a esquerda, o mecanismo de expressão regular pesquisa do caractere no índice beginning + length - 1 para o caractere no índice beginning.

Esse método retorna a primeira correspondência encontrada dentro desse intervalo. Você pode recuperar correspondências subsequentes chamando repetidamente o método do Match.NextMatch objeto retornadoMatch.

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

Match(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Pesquisa a cadeia de caracteres de entrada da primeira ocorrência da expressão regular especificada, usando as opções de correspondência e intervalo de tempo limite especificados.

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

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

Match

Um objeto que contém informações sobre a correspondência.

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores de RegexOptions.

- ou -

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

RegexMatchTimeoutException

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

Comentários

O Match(String, String, RegexOptions, TimeSpan) método retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular – Referência Rápida.

O método estático Match(String, String, RegexOptions, TimeSpan) é equivalente à construção de um Regex objeto com o Regex(String, RegexOptions, TimeSpan) construtor e à chamada do método de instância Match(String) .

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 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 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ão regular oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite somente 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

Linguagem de expressões regulares – referência rápida

Aplica-se a

Regex.Match Método

Definição

Sobrecargas

Match(String, String, RegexOptions)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Match(String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Match(String, Int32)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Match(String, String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Match(String, Int32, Int32)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Match(String, String, RegexOptions, TimeSpan)

Parâmetros

Retornos

Exceções

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Comentários

Recursos adicionais