Regex.Matches Metodo

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

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

Parametri

Restituisce

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

Eccezioni

Esempio

Nell'esempio seguente viene chiamato il Matches(String, String, RegexOptions, TimeSpan) metodo per eseguire un confronto con distinzione tra maiuscole e minuscole corrispondente a qualsiasi parola in una frase che termina con "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 nell'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 modello di espressione regolare \b\w+es\b è definito come mostrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza al limite di una parola.
\w+	Trova la corrispondenza di uno o più caratteri di parola.
es	Trova la corrispondenza con la stringa letterale "es".
\b	Termina la partita al confine di una parola.

Commenti

Il Matches(String, String, RegexOptions, TimeSpan) metodo è simile al metodo , ad eccezione del Match(String, String, RegexOptions, TimeSpan) 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 sono equivalenti Matches alla costruzione di un Regex oggetto con il criterio 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 - Guida di riferimento rapido.

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 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 delle espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:

• Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile o è costituito da testo statico. Questo esclude il testo che è stato immesso dinamicamente dagli utenti.

• Quando il criterio di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.

• Quando il criterio 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 delle espressioni regolari

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

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

Parametri

Restituisce

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

Eccezioni

Esempio

Nell'esempio seguente viene chiamato il Matches(String, String) metodo per identificare qualsiasi parola in una frase che termina in "es" e quindi chiama il Matches(String, String, RegexOptions) metodo per eseguire un confronto senza distinzione tra maiuscole e minuscole del modello con la stringa di input. Come illustrato nell'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 modello di espressione regolare \b\w+es\b è definito come mostrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza al limite di una parola.
\w+	Trova la corrispondenza di uno o più caratteri di parola.
es	Trova la corrispondenza con la stringa letterale "es".
\b	Termina la partita al confine di una parola.

Commenti

Il Matches(String, String, RegexOptions) metodo è simile al metodo , ad eccezione del Match(String, String, RegexOptions) 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 sono equivalenti Matches alla costruzione di un Regex oggetto con il criterio 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 - Guida di riferimento rapido.

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, 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 per il dominio applicazione non è stato definito un valore di timeout, viene usato 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 impostare l'intervallo di timeout.

Vedi anche

• Elementi del linguaggio delle espressioni regolari

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

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

Parametri

Restituisce

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

Eccezioni

Esempio

Nell'esempio seguente viene usato il Match(String) metodo per trovare la prima parola in una frase che termina in "es" e quindi chiama il 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 modello di espressione regolare \b\w+es\b è definito come mostrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza al limite di una parola.
\w+	Trova la corrispondenza di uno o più caratteri di parola.
es	Trova la corrispondenza con la stringa letterale "es".
\b	Termina la partita al confine di una parola.

Commenti

Il Matches(String, Int32) metodo è simile al metodo , ad eccezione del Match(String, Int32) 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 modello di espressione regolare per cui il metodo Matches(String, Int32) cerca è definito dalla chiamata a uno dei costruttori della classe Regex. Per altre informazioni sugli elementi che possono formare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

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 delle espressioni regolari

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

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

Parametri

Restituisce

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

Eccezioni

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 modello di espressione regolare \b\w+es\b è definito come mostrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza al limite di una parola.
\w+	Trova la corrispondenza di uno o più caratteri di parola.
es	Trova la corrispondenza con la stringa letterale "es".
\b	Termina la partita al confine di una parola.

Commenti

Il Matches(String) metodo è simile al metodo , ad eccezione del Match(String) 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 modello di espressione regolare per cui il metodo Matches(String) cerca è definito dalla chiamata a uno dei costruttori della classe Regex. Per altre informazioni sugli elementi che possono formare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

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) 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 delle espressioni regolari

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

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

Parametri

Restituisce

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

Eccezioni

Esempio

Nell'esempio seguente viene usato il Matches(String, String) metodo per identificare qualsiasi parola in una frase che termina in "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 modello di espressione regolare \b\w+es\b è definito come mostrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza al limite di una parola.
\w+	Trova la corrispondenza di uno o più caratteri di parola.
es	Trova la corrispondenza con la stringa letterale "es".
\b	Termina la partita al confine di una parola.

Commenti

Il Matches(String, String) metodo è simile al metodo , ad eccezione del Match(String, String) 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 sono equivalenti Matches alla costruzione di un Regex oggetto con il criterio 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 - Guida di riferimento rapido.

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, 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 per il dominio applicazione non è stato definito un valore di timeout, viene usato 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 delle espressioni regolari