Regex.Matches Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Cerca in una stringa di input tutte le occorrenze di un'espressione regolare e restituisce tutte le corrispondenze.

Overload

Matches(String, String, RegexOptions, TimeSpan)	Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata usando le opzioni di corrispondenza e l'intervallo di timeout specificati.
Matches(String, String, RegexOptions)	Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata usando le opzioni di corrispondenza specificate.
Matches(String, Int32)	Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare, partendo dalla posizione iniziale specificata nella stringa.
Matches(String)	Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare.
Matches(String, String)	Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata.

Matches(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata usando le opzioni di corrispondenza e l'intervallo di timeout specificati.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

pattern: String

Criterio di espressione regolare di cui trovare la corrispondenza.

options: RegexOptions

Combinazione bit per bit dei valori di enumerazione che specificano le opzioni per la corrispondenza.

matchTimeout: TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.

Restituisce

MatchCollection

Raccolta di oggetti Match trovati dalla ricerca. Se non vengono trovate corrispondenze, il metodo restituisce un oggetto raccolta vuoto.

Eccezioni

ArgumentException

Si è verificato un errore di analisi dell'espressione regolare.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

options non è una combinazione bit per bit valida di valori di RegexOptions.

-oppure-

matchTimeout è negativo, zero o maggiore di circa 24 giorni.

Esempio

Nell'esempio seguente viene chiamato il Matches(String, String, RegexOptions, TimeSpan) metodo per eseguire un confronto con distinzione tra maiuscole e minuscole che corrisponde a qualsiasi parola in una frase che termina in "es". Chiama quindi il Matches(String, String, RegexOptions, TimeSpan) metodo per eseguire un confronto senza distinzione tra maiuscole e minuscole del modello con la stringa di input. In entrambi i casi, l'intervallo di timeout viene impostato su un secondo. Come illustrato dall'output, i due metodi restituiscono risultati diversi.

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

Il criterio di ricerca di espressioni regolari \b\w+es\b è definito nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`\w+`	Trova la corrispondenza di uno o più caratteri alfanumerici.
`es`	Corrisponde alla stringa letterale "es".
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Matches(String, String, RegexOptions, TimeSpan) metodo è simile al Match(String, String, RegexOptions, TimeSpan) metodo, ad eccezione del fatto che restituisce informazioni su tutte le corrispondenze trovate nella stringa di input, anziché una singola corrispondenza. Equivale al codice seguente:

   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

I metodi statici Matches sono equivalenti alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e la chiamata al metodo Matchesdi istanza .

Il pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressione regolare - Riferimento rapido.

Il Matches metodo usa la valutazione lazy per popolare l'oggetto restituito MatchCollection . L'accesso ai membri di questa raccolta, ad esempio MatchCollection.Count e MatchCollection.CopyTo causa la popolamento immediato della raccolta. Per sfruttare la valutazione lazy, è consigliabile eseguire l'iterazione della raccolta usando un costrutto come foreach in C# e For Each...Next in Visual Basic.

A causa della valutazione lazy, la chiamata al Matches metodo non genera un'eccezione RegexMatchTimeoutException . Tuttavia, viene generata un'eccezione quando viene eseguita un'operazione sull'oggetto MatchCollection restituito da questo metodo, se un'operazione corrispondente supera questo intervallo di timeout specificato dalmatchTimeout parametro.

Note per i chiamanti

È consigliabile impostare il matchTimeout parametro su un valore appropriato, ad esempio due secondi. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore di espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo in base alle condizioni seguenti:

Quando l'input elaborato da un'espressione regolare deriva da un'origine nota e attendibile o è costituita da testo statico. Ciò esclude il testo che è stato immesso dinamicamente dagli utenti.
Quando il modello di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.
Quando il modello di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.

Vedi anche

Elementi del linguaggio di espressioni regolari

Si applica a

Matches(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata usando le opzioni di corrispondenza specificate.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

pattern: String

Criterio di espressione regolare di cui trovare la corrispondenza.

options: RegexOptions

Combinazione bit per bit dei valori di enumerazione che specificano le opzioni per la corrispondenza.

Restituisce

MatchCollection

Raccolta di oggetti Match trovati dalla ricerca. Se non vengono trovate corrispondenze, il metodo restituisce un oggetto raccolta vuoto.

Eccezioni

ArgumentException

Si è verificato un errore di analisi dell'espressione regolare.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

options non è una combinazione bit per bit valida di valori di RegexOptions.

Esempio

Nell'esempio seguente viene chiamato il metodo per identificare qualsiasi parola in una frase che termina in "es" e quindi chiama il Matches(String, String)Matches(String, String, RegexOptions) metodo per eseguire un confronto senza distinzione tra maiuscole e minuscole del modello con la stringa di input. Come illustrato dall'output, i due metodi restituiscono risultati diversi.

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

Il criterio di ricerca di espressioni regolari \b\w+es\b è definito nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`\w+`	Trova la corrispondenza di uno o più caratteri alfanumerici.
`es`	Corrisponde alla stringa letterale "es".
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Matches(String, String, RegexOptions) metodo è simile al Match(String, String, RegexOptions) metodo, ad eccezione del fatto che restituisce informazioni su tutte le corrispondenze trovate nella stringa di input, anziché una singola corrispondenza. Equivale al codice seguente:

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

I metodi statici Matches sono equivalenti alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e la chiamata al metodo Matchesdi istanza .

A causa della valutazione lazy, la chiamata al Matches(String, String) metodo non genera un'eccezione RegexMatchTimeoutException . Tuttavia, l'eccezione viene generata quando un'operazione viene eseguita sull'oggetto MatchCollection restituito da questo metodo, se un intervallo di timeout viene definito dalla proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" del dominio applicazione corrente e un'operazione corrispondente supera questo intervallo di timeout.

Note per i chiamanti

Questo metodo viene eseguito il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato. Se un valore di timeout non è stato definito per il dominio dell'applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per il recupero di più corrispondenze di criterio è Matches(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

Vedi anche

Elementi del linguaggio di espressioni regolari

Si applica a

Matches(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare, partendo dalla posizione iniziale specificata nella stringa.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

startat: Int32

Posizione del carattere nella stringa di input dalla quale iniziare la ricerca.

Restituisce

MatchCollection

Raccolta di oggetti Match trovati dalla ricerca. Se non vengono trovate corrispondenze, il metodo restituisce un oggetto raccolta vuoto.

Eccezioni

ArgumentNullException

input è null.

ArgumentOutOfRangeException

startat è minore di zero o maggiore della lunghezza di input.

Esempio

Nell'esempio seguente viene usato il metodo per trovare la prima parola in una frase che termina in "es" e quindi chiama il Match(String)Matches(String, Int32) metodo per identificare eventuali parole aggiuntive che terminano in "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

Il criterio di ricerca di espressioni regolari \b\w+es\b è definito nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`\w+`	Trova la corrispondenza di uno o più caratteri alfanumerici.
`es`	Corrisponde alla stringa letterale "es".
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Matches(String, Int32) metodo è simile al Match(String, Int32) metodo, ad eccezione del fatto che restituisce informazioni su tutte le corrispondenze trovate nella stringa di input, anziché una singola corrispondenza. Equivale al codice seguente:

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

Il criterio di espressione regolare per il quale il Matches(String, Int32) metodo esegue la ricerca viene definito dalla chiamata a uno dei costruttori della Regex classe. Per altre informazioni sugli elementi che possono formare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.

Per altre informazioni su startat, vedere la sezione Osservazioni di Match(String, Int32).

Il Matches metodo usa la valutazione differita per popolare l'oggetto restituito MatchCollection . L'accesso ai membri di questa raccolta, MatchCollection.Count ad esempio e MatchCollection.CopyTo fa sì che la raccolta venga popolata immediatamente. Per sfruttare i vantaggi della valutazione differita, è necessario scorrere la raccolta usando un costrutto come foreach in C# e For Each...Next in Visual Basic.

A causa della valutazione differita, la chiamata al Matches(String, Int32) metodo non genera un'eccezione RegexMatchTimeoutException . Tuttavia, l'eccezione viene generata quando viene eseguita un'operazione sull'oggetto MatchCollection restituito da questo metodo, se la MatchTimeout proprietà non Regex.InfiniteMatchTimeout è e un'operazione corrispondente supera l'intervallo di timeout.

Vedi anche

Elementi del linguaggio di espressioni regolari

Si applica a

Matches(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

Restituisce

MatchCollection

Raccolta di oggetti Match trovati dalla ricerca. Se non vengono trovate corrispondenze, il metodo restituisce un oggetto raccolta vuoto.

Eccezioni

ArgumentNullException

input è null.

Esempio

Nell'esempio seguente viene usato il Matches(String) metodo per identificare le parole in una frase che terminano in "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

Il criterio di ricerca di espressioni regolari \b\w+es\b è definito nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`\w+`	Trova la corrispondenza di uno o più caratteri alfanumerici.
`es`	Trova la corrispondenza con la stringa letterale "es".
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Matches(String) metodo è simile al Match(String) metodo , ad eccezione del fatto che restituisce informazioni su tutte le corrispondenze trovate nella stringa di input, anziché una singola corrispondenza. Equivale al codice seguente:

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

La raccolta include solo corrispondenze e termina alla prima non corrispondenza.

Il criterio di espressione regolare per il quale il Matches(String) metodo esegue la ricerca viene definito dalla chiamata a uno dei costruttori della Regex classe. Per altre informazioni sugli elementi che possono formare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.

A causa della valutazione differita, la chiamata al Matches(String) metodo non genera un'eccezione RegexMatchTimeoutException . Tuttavia, l'eccezione viene generata quando viene eseguita un'operazione sull'oggetto MatchCollection restituito da questo metodo, se la MatchTimeout proprietà non Regex.InfiniteMatchTimeout è e un'operazione corrispondente supera l'intervallo di timeout.

Vedi anche

Elementi del linguaggio di espressioni regolari

Si applica a

Matches(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata tutte le occorrenze di un'espressione regolare specificata.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

pattern: String

Criterio di espressione regolare di cui trovare la corrispondenza.

Restituisce

MatchCollection

Raccolta di oggetti Match trovati dalla ricerca. Se non vengono trovate corrispondenze, il metodo restituisce un oggetto raccolta vuoto.

Eccezioni

ArgumentException

Si è verificato un errore di analisi dell'espressione regolare.

ArgumentNullException

input o pattern è null.

Esempio

Nell'esempio seguente viene utilizzato il Matches(String, String) metodo per identificare qualsiasi parola in una frase che termina con "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

Il criterio di ricerca di espressioni regolari \b\w+es\b è definito nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`\w+`	Trova la corrispondenza di uno o più caratteri alfanumerici.
`es`	Trova la corrispondenza con la stringa letterale "es".
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Matches(String, String) metodo è simile al Match(String, String) metodo , ad eccezione del fatto che restituisce informazioni su tutte le corrispondenze trovate nella stringa di input, anziché una singola corrispondenza. Equivale al codice seguente:

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

I metodi statici Matches sono equivalenti alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e la chiamata al metodo Matchesdi istanza .

Il pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.

A causa della valutazione differita, la chiamata al Matches(String, String) metodo non genera un'eccezione RegexMatchTimeoutException . Tuttavia, l'eccezione viene generata quando viene eseguita un'operazione sull'oggetto MatchCollection restituito da questo metodo, se un intervallo di timeout viene definito dalla proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" del dominio applicazione corrente e un'operazione corrispondente supera questo intervallo di timeout.

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato. Se non è stato definito un valore di timeout per il dominio applicazione, viene utilizzato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per il recupero di più corrispondenze di criteri è Matches(String, String, RegexOptions, TimeSpan), che consente di specificare l'intervallo di timeout.

Vedi anche

Elementi del linguaggio di espressioni regolari

Si applica a

Regex.Matches Metodo

Definizione

Overload

Matches(String, String, RegexOptions, TimeSpan)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Matches(String, String, RegexOptions)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Matches(String, Int32)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Matches(String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Matches(String, String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive