Regex.Match 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 una sottostringa che corrisponda al criterio di espressione regolare e restituisce la prima ricorrenza come singolo oggetto Match.

Overload

Match(String, String, RegexOptions)	Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata usando le opzioni di corrispondenza specificate.
Match(String)	Cerca nella stringa di input specificata la prima ricorrenza dell'espressione regolare specificata nel costruttore Regex.
Match(String, Int32)	Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata nella stringa.
Match(String, String)	Cerca nella stringa di input specificata la prima occorrenza dell'espressione regolare specificata.
Match(String, Int32, Int32)	Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata e cercando solo nel numero di caratteri specificato.
Match(String, String, RegexOptions, TimeSpan)	Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata usando le opzioni di corrispondenza e l'intervallo di timeout specificati.

Match(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata usando le opzioni di corrispondenza specificate.

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

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 forniscono le opzioni per la corrispondenza.

Restituisce

Match

Oggetto contenente informazioni sulla corrispondenza.

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.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Esempio

Nell'esempio seguente viene definita un'espressione regolare che corrisponde alle parole che iniziano con la lettera "a". Usa l'opzione RegexOptions.IgnoreCase per assicurarsi che l'espressione regolare individui le parole che iniziano con una "a" maiuscola e una minuscola "a".

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.

Il criterio di ricerca di espressioni regolari \ba\w*\b è interpretato nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`a`	Trova la corrispondenza con il carattere "a".
`\w*`	Trova la corrispondenza con zero, uno o più caratteri di parola.
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Match(String, String, RegexOptions) metodo restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il metodo statico Match(String, String, RegexOptions) equivale a costruire un Regex oggetto con il Regex(String, RegexOptions) costruttore e a chiamare il metodo di istanza Match(String) .

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.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore della proprietà dell'oggetto Success restituitoMatch. Se viene trovata una corrispondenza, la proprietà dell'oggetto Value restituito Match contiene la sottostringa da input che corrisponde al criterio di espressione regolare. Se non viene trovata alcuna corrispondenza, il relativo valore è String.Empty.

Questo metodo restituisce la prima sottostringa trovata in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo dell'oggetto NextMatch restituitoMatch. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il Regex.Matches(String, String, RegexOptions) metodo .

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo . Se non viene definito alcun timeout nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

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 una corrispondenza del criterio è Match(String, String), che consente di impostare l'intervallo di timeout.

Vedi anche

Si applica a

Match(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata la prima ricorrenza dell'espressione regolare specificata nel costruttore 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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

Restituisce

Match

Oggetto contenente informazioni sulla corrispondenza.

Eccezioni

ArgumentNullException

input è null.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Esempio

Nell'esempio seguente vengono trovate corrispondenze di criteri di espressione regolare in una stringa, quindi vengono elencati i gruppi corrispondenti, le acquisizioni e le posizioni di acquisizione.

#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

Il criterio (\w+)\s+(car) di espressione regolare corrisponde alle occorrenze della parola "car" insieme alla parola che lo precede. Viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
`(\w+)`	Trova la corrispondenza di uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.
`\s+`	Trova la corrispondenza con uno o più caratteri di spazio vuoto.
(auto)	Trova la corrispondenza con la stringa letterale "car". Equivale al secondo gruppo di acquisizione.

Commenti

Il Match(String) metodo restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Questo metodo restituisce la prima sottostringa in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo dell'oggetto Match.NextMatch restituitoMatch. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il Regex.Matches(String) metodo .

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata al Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Vedi anche

Si applica a

Match(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata nella stringa.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

startat: Int32

Posizione del carattere in base zero dalla quale iniziare la ricerca.

Restituisce

Match

Oggetto contenente informazioni sulla corrispondenza.

Eccezioni

ArgumentNullException

input è null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

Per altre informazioni su questa API, vedere Note sulle API supplementari per Regex.Match.

Vedi anche

Si applica a

Match(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input specificata la prima occorrenza dell'espressione regolare specificata.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

pattern: String

Criterio di espressione regolare di cui trovare la corrispondenza.

Restituisce

Match

Oggetto contenente informazioni sulla corrispondenza.

Eccezioni

ArgumentException

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

ArgumentNullException

input o pattern è null.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Esempio

Nell'esempio seguente viene chiamato il Match(String, String) metodo per trovare la prima parola contenente almeno un z carattere e quindi viene chiamato il Match.NextMatch metodo per trovare eventuali corrispondenze aggiuntive.

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

Il criterio di ricerca di espressioni regolari \b\w*z+\w*\b è interpretato nel modo illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Inizia la corrispondenza sul confine di parola.
`\w*`	Trova la corrispondenza con zero, uno o più caratteri di parola.
`z+`	Trova la corrispondenza con una o più occorrenze del `z` carattere.
`\w*`	Trova la corrispondenza con zero, uno o più caratteri di parola.
`\b`	Termina la corrispondenza sul confine di parola.

Commenti

Il Match(String, String) metodo restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il metodo statico Match(String, String) equivale a costruire un Regex oggetto con il modello di espressione regolare specificato e chiamando il metodo di istanza Match(String) . In questo caso, il motore delle espressioni regolari memorizza nella cache il modello di espressione regolare.

Note per i chiamanti

Vedi anche

Si applica a

Match(String, Int32, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata e cercando solo nel numero di caratteri specificato.

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

Parametri

input: String

Stringa nella quale cercare una corrispondenza.

beginning: Int32

Posizione del carattere in base zero nella stringa di input che definisce la posizione più a sinistra in cui cercare.

length: Int32

Numero di caratteri nella sottostringa da includere nella ricerca.

Restituisce

Match

Oggetto contenente informazioni sulla corrispondenza.

Eccezioni

ArgumentNullException

input è null.

ArgumentOutOfRangeException

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

-oppure-

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

-oppure-

beginning+length-1 identifica una posizione esterna all'intervallo di input.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

Il Match(String, Int32, Int32) metodo restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una parte di una stringa di input. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il criterio di espressione regolare per il quale il Match(String, Int32, 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.

Il Match(String, Int32, Int32) metodo cerca la parte di input definita dai beginning parametri e length per il criterio di espressione regolare. beginning definisce sempre l'indice del carattere più a sinistra da includere nella ricerca e length definisce il numero massimo di caratteri da cercare. Insieme, definiscono l'intervallo della ricerca. Il comportamento è esattamente come se fosse inputinput.Substring(beginning, length)effettivamente , ad eccezione del fatto che l'indice di qualsiasi corrispondenza viene conteggiato rispetto all'inizio di input. Ciò significa che tutti gli ancoraggi o le asserzioni a larghezza zero all'inizio o alla fine del criterio si comportano come se non vi fosse alcun input elemento esterno a questo intervallo. Ad esempio, gli ancoraggi ^, \Ge \A verranno soddisfatti in beginning e $ e \z saranno soddisfatti in beginning + length - 1.

Se la ricerca procede da sinistra a destra (impostazione predefinita), il motore delle espressioni regolari cerca dal carattere in corrispondenza dell'indice beginning al carattere in corrispondenza dell'indice beginning + length - 1. Se è stata creata un'istanza del motore delle espressioni regolari usando l'opzione RegexOptions.RightToLeft in modo che la ricerca procede da destra a sinistra, il motore delle espressioni regolari esegue la ricerca dal carattere in corrispondenza dell'indice al carattere in corrispondenza dell'indice beginning + length - 1beginning.

Questo metodo restituisce la prima corrispondenza trovata all'interno di questo intervallo. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo dell'oggetto Match.NextMatch restituitoMatch.

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un valore di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata al Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Vedi anche

Si applica a

Match(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata usando le opzioni di corrispondenza e l'intervallo di timeout specificati.

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

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 forniscono le opzioni per la corrispondenza.

matchTimeout: TimeSpan

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

Restituisce

Match

Oggetto contenente informazioni sulla corrispondenza.

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.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

Il Match(String, String, RegexOptions, TimeSpan) metodo restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere Regular Expression Language - Quick Reference.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il metodo statico Match(String, String, RegexOptions, TimeSpan) equivale a costruire un Regex oggetto con il Regex(String, RegexOptions, TimeSpan) costruttore e a chiamare il metodo di istanza Match(String) .

Il matchTimeout parametro specifica per quanto tempo un metodo di corrispondenza dei criteri deve tentare di trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce la visualizzazione di espressioni regolari basate su un backtracking eccessivo per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere Procedure consigliate per espressioni regolari e backtracking. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo genera un'eccezione RegexMatchTimeoutException . matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui viene eseguito il metodo.

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. Esclude il testo 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

Linguaggio di espressioni regolari - Riferimento rapido

Si applica a

Regex.Match Metodo

Definizione

Overload

Match(String, String, RegexOptions)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Match(String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Match(String, Int32)

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

Match(String, String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Match(String, Int32, Int32)

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

Match(String, String, RegexOptions, TimeSpan)

Parametri

Restituisce

Eccezioni

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive