Regex.Match Método

Definição

Namespace:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

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

Match(String)

Origem:

Regex.Match.cs

Pesquisa a cadeia de caracteres de entrada especificada para a primeira ocorrência da expressão regular 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 a ser pesquisada por 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 de expressão regular (\w+)\s+(car) corresponde às ocorrências da palavra "carro" junto com a palavra que o precede. Ele é interpretado conforme mostrado na tabela a seguir.

Padrão	Descrição
(\w+)	Corresponde 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 método Match(String) 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.

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

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 de Match.NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String).

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

• NextMatch()
• linguagem de expressão regular – referência rápida

Match(String, Int32)

Origem:

Regex.Match.cs

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

startat

Int32

A posição do caractere baseado 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 comprimento 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 da API Suplementar para Regex.Match.

Confira também

• NextMatch()
• linguagem de expressão regular – referência rápida

Match(String, String)

Origem:

Regex.Match.cs

Pesquisa a cadeia de caracteres de entrada especificada para a primeira ocorrência da expressão regular 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 a ser pesquisada por uma correspondência.

pattern

String

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

Retornos

Match

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

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

O exemplo a seguir chama o método Match(String, String) para localizar a primeira palavra que contém pelo menos um caractere z e, em seguida, chama o método Match.NextMatch 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 de expressão regular \b\w*z+\w*\b é interpretado conforme mostrado na tabela a seguir.

Padrão	Descrição
\b	Inicie 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 caractere z.
\w*	Corresponder a zero, um ou mais caracteres de palavra.
\b	Encerre a correspondência em um limite de palavra.

Comentários

O método Match(String, String) 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 Match(String, String) estático é equivalente à construção de um objeto Regex com o padrão de expressão regular especificado e chamar a instância Match(String) método. Nesse caso, o mecanismo de expressão regular armazena em cache o padrão 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.

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

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 de Match.NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String).

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 recuperar uma correspondência de padrão é Match(String, String), o que permite definir o intervalo de tempo limite.

Confira também

• NextMatch()
• linguagem de expressão regular – referência rápida

Match(String, Int32, Int32)

Origem:

Regex.Match.cs

Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, 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 a ser pesquisada por 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 serem incluídos 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 comprimento de input.

-ou-

length é menor que zero ou maior que o comprimento 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 método Match(String, Int32, Int32) 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 método Match(String, Int32, Int32) pesquisa é definido pela chamada para um dos construtores de classe Regex. 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 método Match(String, Int32, Int32) pesquisa a parte de input definida pelos parâmetros beginning 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 as âncoras ou asserções de largura zero no início ou no final do padrão se comportam como se não houvesse input fora desse intervalo. Por exemplo, as âncoras ^, \Ge \A serão atendidas em beginning e $ e \z serão atendidos 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 tiver sido 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 de Match.NextMatch do objeto Match retornado.

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

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

• NextMatch()
• linguagem de expressão regular – referência rápida

Match(String, String, RegexOptions)

Origem:

Regex.Match.cs

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

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

Match

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

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores 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 de expressão regular \ba\w*\b é interpretado conforme mostrado na tabela a seguir.

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

Comentários

O método Match(String, String, RegexOptions) 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 Match(String, String, RegexOptions) estático é equivalente a construir um objeto Regex com o construtor Regex(String, RegexOptions) e chamar a instância Match(String) método.

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.

Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input que corresponde ao padrão de 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 de NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String, RegexOptions).

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 recuperar uma correspondência de padrão é Match(String, String), o que permite definir o intervalo de tempo limite.

Confira também

• NextMatch()
• linguagem de expressão regular – referência rápida

Match(String, String, RegexOptions, TimeSpan)

Origem:

Regex.Match.cs

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

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

Match

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

Exceções

ArgumentException

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

ArgumentNullException

input ou pattern é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores 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 método Match(String, String, RegexOptions, TimeSpan) 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 Match(String, String, RegexOptions, TimeSpan) estático é equivalente a construir um objeto Regex com o construtor Regex(String, RegexOptions, TimeSpan) e chamar a instância Match(String) método.

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.

Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input que corresponde ao padrão de 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 de NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String, RegexOptions).

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

• linguagem de expressão regular – referência rápida