Regex.Matches Método

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Matches : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.MatchCollection

Public Shared Function Matches (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As MatchCollection

Parâmetros

Retornos

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

Exemplos

O exemplo a seguir chama o Matches(String, String, RegexOptions, TimeSpan) método para executar uma comparação que diferencia maiúsculas de minúsculas que corresponda a qualquer palavra em uma frase que termine em "es". Em seguida, ele chama o Matches(String, String, RegexOptions, TimeSpan) método para executar uma comparação que não diferencia maiúsculas de minúsculas do padrão com a cadeia de caracteres de entrada. Em ambos os casos, o intervalo de tempo limite é definido como um segundo. Como mostra a saída, os dois métodos retornam resultados diferentes.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      try {
         foreach (Match match in Regex.Matches(sentence, pattern,
                                               RegexOptions.None,
                                               TimeSpan.FromSeconds(1)))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {
         // Do Nothing: Assume that timeout represents no match.
      }
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      try { 
         foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
            Console.WriteLine("Found '{0}' at position {1}", 
                              match.Value, match.Index);
      }
      catch (RegexMatchTimeoutException) {}
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern, 
                                               RegexOptions.None, 
                                               TimeSpan.FromSeconds(1))
         Try
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Catch e As RegexMatchTimeoutException
            ' Do Nothing: Assume that timeout represents no match.
         End Try
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      Try
         For Each match As Match In Regex.Matches(sentence, pattern, 
                                                  RegexOptions.IgnoreCase,
                                                  TimeSpan.FromSeconds(1))
            Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
         Next
      Catch de As RegexMatchTimeoutException
         ' Do Nothing: Assume that timeout represents no match.
      End Try
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Comentários

O Matches(String, String, RegexOptions, TimeSpan) método é semelhante ao Match(String, String, RegexOptions, TimeSpan) método , exceto que ele retorna informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

   try {
      Match match = Regex.Match(input, pattern, options,
                                TimeSpan.FromSeconds(1));
      while (match.Success) {
            // Handle match here...

            match = match.NextMatch();
      }  
   }
   catch (RegexMatchTimeoutException) {
      // Do nothing: assume that exception represents no match.
   }

   Try
      Dim match As Match = Regex.Match(input, pattern, options, 
                                       TimeSpan.FromSeconds(1))
      Do While match.Success
            ' Handle match here...

            match = match.NextMatch()
      Loop  
   Catch e As RegexMatchTimeoutException
      ' Do nothing: assume that exception represents no match.
   End Try

Os métodos estáticos Matches são equivalentes a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método Matchesde instância .

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

O Matches método usa a avaliação lenta para preencher o objeto retornado MatchCollection . Acessar membros dessa coleção como MatchCollection.Count e MatchCollection.CopyTo faz com que a coleção seja preenchida imediatamente. Para aproveitar a avaliação lenta, você deve iterar a coleção usando um constructo como foreach em C# e For Each...Next no Visual Basic.

Devido à avaliação lenta, chamar o Matches método não gera uma RegexMatchTimeoutException exceção. No entanto, uma exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se uma operação correspondente exceder esse intervalo de tempo limite especificado pelomatchTimeout parâmetro .

Notas aos Chamadores

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

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

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

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

Confira também

• Elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection

Public Shared Function Matches (input As String, pattern As String, options As RegexOptions) As MatchCollection

Parâmetros

Retornos

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

Exemplos

O exemplo a seguir chama o Matches(String, String) método para identificar qualquer palavra em uma frase que termina em "es" e, em seguida, chama o Matches(String, String, RegexOptions) método para executar uma comparação que não diferencia maiúsculas de minúsculas do padrão com a cadeia de caracteres de entrada. Como mostra a saída, os dois métodos retornam resultados diferentes.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "NOTES: Any notes or comments are optional.";
      
      // Call Matches method without specifying any options.
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
      Console.WriteLine();

      // Call Matches method for case-insensitive matching.
      foreach (Match match in Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'notes' at position 11
//       
//       Found 'NOTES' at position 0
//       Found 'notes' at position 11

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "NOTES: Any notes or comments are optional."
      
      ' Call Matches method without specifying any options.
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
      Console.WriteLine()
      
      ' Call Matches method for case-insensitive matching.
      For Each match As Match In Regex.Matches(sentence, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'notes' at position 11
'       
'       Found 'NOTES' at position 0
'       Found 'notes' at position 11

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Comentários

O Matches(String, String, RegexOptions) método é semelhante ao Match(String, String, RegexOptions) método , exceto que ele retorna informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

Match match = Regex.Match(input, pattern, options);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = Regex.Match(input, pattern, options)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Os métodos estáticos Matches são equivalentes a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método Matchesde instância .

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

O Matches método usa a avaliação lenta para preencher o objeto retornado MatchCollection . Acessar membros dessa coleção como MatchCollection.Count e MatchCollection.CopyTo faz com que a coleção seja preenchida imediatamente. Para aproveitar a avaliação lenta, você deve iterar a coleção usando um constructo como foreach em C# e For Each...Next no Visual Basic.

Devido à avaliação lenta, chamar o Matches(String, String) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se um intervalo de tempo limite for definido pela propriedade "REGEX_DEFAULT_MATCH_TIMEOUT" do domínio do aplicativo atual e uma operação correspondente exceder esse intervalo de tempo limite.

Notas aos Chamadores

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

Confira também

• Elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, int startat);

public System.Text.RegularExpressions.MatchCollection Matches (string input, int startat);

member this.Matches : string * int -> System.Text.RegularExpressions.MatchCollection

Public Function Matches (input As String, startat As Integer) As MatchCollection

Parâmetros

Retornos

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

Exemplos

O exemplo a seguir usa o Match(String) método para localizar a primeira palavra em uma frase que termina em "es" e, em seguida, chama o Matches(String, Int32) método para identificar as palavras adicionais que terminam em "es".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes and uses our paper?";
      
      // Get the first match.
      Match match = rgx.Match(sentence);
      if (match.Success) {
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", 
                           match.Value, match.Index);
         // Get any additional matches.
         foreach (Match m in rgx.Matches(sentence, match.Index + match.Length))
            Console.WriteLine("Also found '{0}' at position {1}", 
                              m.Value, m.Index);
      }   
   }
}
// The example displays the following output:
//       Found first 'es' in 'writes' at position 4
//       Also found 'notes' at position 17
//       Also found 'uses' at position 27

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes and uses our paper?"
      
      ' Get the first match.
      Dim match As Match = rgx.Match(sentence)
      If match.Success Then
         Console.WriteLine("Found first 'es' in '{0}' at position {1}", _
                           match.Value, match.Index)
         ' Get any additional matches.
         For Each match In rgx.Matches(sentence, match.Index + match.Length)
            Console.WriteLine("Also found '{0}' at position {1}", _
                              match.Value, match.Index)
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Found first 'es' in 'writes' at position 4
'       Also found 'notes' at position 17
'       Also found 'uses' at position 27

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Comentários

O Matches(String, Int32) método é semelhante ao Match(String, Int32) método , exceto que ele retorna informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

Match match = regex.Match(input, startAt);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = regex.Match(input, startAt)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

O padrão de expressão regular para o qual o Matches(String, 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.

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

O Matches método usa a avaliação lenta para preencher o objeto retornado MatchCollection . Acessar membros dessa coleção como MatchCollection.Count e MatchCollection.CopyTo faz com que a coleção seja preenchida imediatamente. Para aproveitar a avaliação lenta, você deve iterar a coleção usando um constructo como foreach em C# e For Each...Next no Visual Basic.

Devido à avaliação lenta, chamar o Matches(String, Int32) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se a MatchTimeout propriedade não Regex.InfiniteMatchTimeout for e uma operação correspondente exceder o intervalo de tempo limite.

Confira também

• Elementos da linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input);

public System.Text.RegularExpressions.MatchCollection Matches (string input);

member this.Matches : string -> System.Text.RegularExpressions.MatchCollection

Public Function Matches (input As String) As MatchCollection

Parâmetros

Retornos

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

Exemplos

O exemplo a seguir usa o Matches(String) método para identificar qualquer palavra em uma frase que termine em "es".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      Regex rgx = new Regex(pattern);
      string sentence = "Who writes these notes?";
      
      foreach (Match match in rgx.Matches(sentence))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim rgx As New Regex(pattern)
      Dim sentence As String = "Who writes these notes?"
      
      For Each match As Match In rgx.Matches(sentence)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Comentários

O Matches(String) método é semelhante ao Match(String) método , exceto pelo fato de retornar informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

Match match = regex.Match(input);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = regex.Match(input)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

A coleção inclui apenas correspondências e termina na primeira não correspondência.

O padrão de expressão regular para o qual o Matches(String) 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 Matches método usa a avaliação lenta para preencher o objeto retornado MatchCollection . Acessar membros dessa coleção como MatchCollection.Count e MatchCollection.CopyTo faz com que a coleção seja preenchida imediatamente. Para aproveitar a avaliação lenta, você deve iterar a coleção usando um constructo como foreach em C# e For Each...Next no Visual Basic.

Devido à avaliação lenta, chamar o Matches(String) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se a MatchTimeout propriedade não Regex.InfiniteMatchTimeout for e uma operação correspondente exceder o intervalo de tempo limite.

Confira também

• Elementos da linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::MatchCollection ^ Matches(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.MatchCollection Matches (string input, string pattern);

static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection

Public Shared Function Matches (input As String, pattern As String) As MatchCollection

Parâmetros

Retornos

Uma coleção dos objetos Match encontrados pela pesquisa. Se nenhuma correspondência for encontrada, o método retornará um objeto de coleção vazio.

Exceções

Exemplos

O exemplo a seguir usa o Matches(String, String) método para identificar qualquer palavra em uma frase que termine em "es".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "Who writes these notes?";
      
      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+es\b"
      Dim sentence As String = "Who writes these notes?"
      For Each match As Match In Regex.Matches(sentence, pattern)
         Console.WriteLine("Found '{0}' at position {1}", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found 'writes' at position 4
'       Found 'notes' at position 17

O padrão de expressão regular \b\w+es\b é definido conforme mostrado na tabela a seguir.

Comentários

O Matches(String, String) método é semelhante ao Match(String, String) método , exceto pelo fato de retornar informações sobre todas as correspondências encontradas na cadeia de caracteres de entrada, em vez de uma única correspondência. É equivalente ao seguinte código:

Match match = Regex.Match(input, pattern);
while (match.Success) {
      // Handle match here...

      match = match.NextMatch();
}

Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
      ' Handle match here...

      match = match.NextMatch()
Loop

Os métodos estáticos Matches são equivalentes a construir um Regex objeto com o padrão de expressão regular especificado e chamar o método Matchesde instância .

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

O Matches método usa a avaliação lenta para preencher o objeto retornado MatchCollection . Acessar membros dessa coleção como MatchCollection.Count e MatchCollection.CopyTo faz com que a coleção seja preenchida imediatamente. Para aproveitar a avaliação lenta, você deve iterar a coleção usando um constructo como foreach em C# e For Each...Next no Visual Basic.

Devido à avaliação lenta, chamar o Matches(String, String) método não gera uma RegexMatchTimeoutException exceção. No entanto, a exceção é gerada quando uma operação é executada no MatchCollection objeto retornado por esse método, se um intervalo de tempo limite for definido pela propriedade "REGEX_DEFAULT_MATCH_TIMEOUT" do domínio do aplicativo atual e uma operação correspondente exceder esse intervalo de tempo limite.

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 várias correspondências de padrão é Matches(String, String, RegexOptions, TimeSpan), que permite especificar o intervalo de tempo limite.

Confira também

• Elementos da linguagem de expressão regular