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 corrisponde a un criterio di espressione regolare e restituisce la prima occorrenza come singolo oggetto Match.

Overload

Match(String)	Cerca nella stringa di input specificata la prima occorrenza 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 il numero specificato di caratteri.
Match(String, String, RegexOptions)	Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata, utilizzando le opzioni di corrispondenza specificate.
Match(String, String, RegexOptions, TimeSpan)	Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata, usando le opzioni di corrispondenza specificate e l'intervallo di timeout.

Match(String)

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Cerca nella stringa di input specificata la prima occorrenza 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 in cui cercare una corrispondenza.

Restituisce

Match

Oggetto che contiene 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, le acquisizioni e le posizioni di acquisizione corrispondenti.

#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 di espressione regolare (\w+)\s+(car) 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 con uno o più caratteri di parola. Si tratta del 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". Questo è il secondo gruppo di acquisizione.

Commenti

Il metodo Match(String) 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 creare un criterio di espressione regolare, vedere 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à Success dell'oggetto restituito Match. Se viene trovata una corrispondenza, la proprietà Value dell'oggetto Match restituita contiene la sottostringa di 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 in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo Match.NextMatch dell'oggetto restituito Match. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il metodo Regex.Matches(String).

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato dal costruttore Regex.Regex(String, RegexOptions, TimeSpan). 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 costruttore Regex o nelle proprietà del dominio applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Vedi anche

NextMatch()
linguaggio delle espressioni regolari - di riferimento rapido

Si applica a

Match(String, Int32)

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Origine:: 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 in cui cercare una corrispondenza.

startat: Int32

Posizione del carattere in base zero in corrispondenza della quale avviare la ricerca.

Restituisce

Match

Oggetto che contiene 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 osservazioni supplementari sull'API per Regex.Match.

Vedi anche

NextMatch()
linguaggio delle espressioni regolari - di riferimento rapido

Si applica a

Match(String, String)

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Origine:: 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 in cui cercare una corrispondenza.

pattern: String

Modello di espressione regolare da trovare in corrispondenza.

Restituisce

Match

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

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 metodo Match(String, String) per trovare la prima parola contenente almeno un carattere z, quindi chiama il metodo Match.NextMatch 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 espressione regolare \b\w*z+\w*\b viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Iniziare la corrispondenza in corrispondenza di un limite di parola.
`\w*`	Trova la corrispondenza con zero, uno o più caratteri di parola.
`z+`	Trova la corrispondenza con una o più occorrenze del carattere `z`.
`\w*`	Trova la corrispondenza con zero, uno o più caratteri di parola.
`\b`	Terminare la corrispondenza in corrispondenza di un limite di parola.

Commenti

Il metodo Match(String, String) 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 creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

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

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato per il dominio 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 usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per il recupero di una corrispondenza dei criteri è Match(String, String), che consente di impostare l'intervallo di timeout.

Vedi anche

NextMatch()
linguaggio delle espressioni regolari - di riferimento rapido

Si applica a

Match(String, Int32, Int32)

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

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

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 in cui cercare una corrispondenza.

beginning: Int32

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

length: Int32

Numero di caratteri nella sottostringa da includere nella ricerca.

Restituisce

Match

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

ArgumentNullException

input è null.

ArgumentOutOfRangeException

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

-o-

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

-o-

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 metodo Match(String, Int32, Int32) 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 creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Modello di espressione regolare per il quale il metodo Match(String, Int32, Int32) cerca è definito dalla chiamata a uno dei costruttori di classi Regex. Per altre informazioni sugli elementi che possono formare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Il metodo Match(String, Int32, Int32) cerca la parte di input definita dai parametri beginning 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 il input fosse effettivamente input.Substring(beginning, length), ad eccezione del fatto che l'indice di qualsiasi corrispondenza viene conteggiato rispetto all'inizio di input. Ciò significa che qualsiasi ancoraggio o asserzione di larghezza zero all'inizio o alla fine del modello si comporta come se non vi sia alcun input all'esterno di questo intervallo. Ad esempio, gli ancoraggi ^, \Ge \A verranno soddisfatti in beginning e $ e \z verranno 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 cerca dal carattere in corrispondenza dell'indice beginning + length - 1 al carattere in corrispondenza dell'indice beginning.

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

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato dal costruttore Regex.Regex(String, RegexOptions, TimeSpan). 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 costruttore Regex o nelle proprietà del dominio applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Vedi anche

NextMatch()
linguaggio delle espressioni regolari - di riferimento rapido

Si applica a

Match(String, String, RegexOptions)

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata, utilizzando 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 in cui cercare una corrispondenza.

pattern: String

Modello di espressione regolare da trovare in corrispondenza.

options: RegexOptions

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

Restituisce

Match

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

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 individua 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 espressione regolare \ba\w*\b viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
`\b`	Iniziare la corrispondenza in corrispondenza di un limite di parola.
`a`	Trova la corrispondenza con il carattere "a".
`\w*`	Trova la corrispondenza con zero, uno o più caratteri di parola.
`\b`	Terminare la corrispondenza in corrispondenza di un limite di parola.

Commenti

Il metodo Match(String, String, RegexOptions) 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 creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

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

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 NextMatch dell'oggetto restituito Match. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il metodo Regex.Matches(String, String, RegexOptions).

Note per i chiamanti

Vedi anche

NextMatch()
linguaggio delle espressioni regolari - di riferimento rapido

Si applica a

Match(String, String, RegexOptions, TimeSpan)

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

Origine:: Regex.Match.cs

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

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 in cui cercare una corrispondenza.

pattern: String

Modello di espressione regolare da trovare in corrispondenza.

options: RegexOptions

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

matchTimeout: TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che il metodo non deve scadere.

Restituisce

Match

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

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

-o-

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 metodo Match(String, String, RegexOptions, TimeSpan) 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 creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

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

Il parametro matchTimeout consente di specificare per quanto tempo un metodo di ricerca dei criteri di ricerca deve provare a trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce che le espressioni regolari che si basano su un backtracking eccessivo vengano visualizzate per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere procedure consigliate per le 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 applicazione in cui viene eseguito il metodo.

Note per i chiamanti

È consigliabile impostare il parametro matchTimeout 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

linguaggio delle espressioni regolari - di riferimento rapido

Si applica a

Condividi tramite

Regex.Match Metodo

Definizione

Overload

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)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Match(String, String, RegexOptions, TimeSpan)

Parametri

Restituisce

Eccezioni

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Risorse aggiuntive