Regex.Match Metodo

Definizione

Cerca in una stringa di input una sottostringa che corrisponda al criterio di espressione regolare e restituisce la prima ricorrenza come singolo oggetto Match.Searches an input string for a substring that matches a regular expression pattern and returns the first occurrence as a single Match object.

Overload

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.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String, RegexOptions)

Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata usando le opzioni di corrispondenza specificate.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, Int32)

Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata nella stringa.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String)

Cerca nella stringa di input specificata la prima ricorrenza dell'espressione regolare specificata nel costruttore Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, String)

Cerca nella stringa di input specificata la prima occorrenza dell'espressione regolare specificata.Searches the specified input string for the first occurrence of the specified regular expression.

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.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

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.The string to search for a match.

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Restituisce

Oggetto contenente informazioni sulla corrispondenza.An object that contains information about the match.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

input o pattern è null.input or pattern is null.

options non è una combinazione bit per bit valida di valori di RegexOptions .options is not a valid bitwise combination of RegexOptions values.

In alternativa-or- matchTimeout è negativo, zero o maggiore di circa 24 giorni.matchTimeout is negative, zero, or greater than approximately 24 days.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

Il Match(String, String, RegexOptions, TimeSpan) metodo restituisce la prima sottostringa corrispondente a un criterio di espressione regolare in una stringa di input.The Match(String, String, RegexOptions, TimeSpan) method returns the first substring that matches a regular expression pattern in an input string. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il metodo Match(String, String, RegexOptions, TimeSpan) statico equivale alla costruzione di un Regex oggetto con il Regex(String, RegexOptions, TimeSpan) costruttore e alla chiamata del metodo Match(String) di istanza.The static Match(String, String, RegexOptions, TimeSpan) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions, TimeSpan) constructor and calling the instance Match(String) method.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

È possibile determinare se il modello di espressione regolare è stato trovato nella stringa di input controllando il valore della Match Success proprietà dell'oggetto restituito.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se viene trovata una corrispondenza, la Match Value proprietà dell'oggetto restituito contiene la sottostringa input da che corrisponde al criterio di espressione regolare.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se non viene trovata alcuna corrispondenza, il relativo String.Emptyvalore è.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa trovata input in che corrisponde al criterio di espressione regolare.This method returns the first substring found in input that matches the regular expression pattern. È possibile recuperare le corrispondenze successive chiamando ripetutamente Match il NextMatch metodo dell'oggetto restituito.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo Regex.Matches(String, String, RegexOptions) chiamando il metodo.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

Il matchTimeout parametro specifica per quanto tempo un metodo di criteri di ricerca deve provare a 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 un input che contiene le corrispondenze vicine.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Per altre informazioni, vedere procedure consigliate per le espressioni regolari e il backtracking. For more information, see Best Practices for Regular Expressions and Backtracking. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo RegexMatchTimeoutException genera un'eccezione.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeoutesegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui viene eseguito il metodo.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Note per i chiamanti

Si consiglia di impostare il matchTimeout parametro su un valore appropriato, ad esempio due secondi.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore delle espressioni regolari offre prestazioni leggermente migliori.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:However, you should disable time-outs only under the following conditions: -Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile oppure è costituito da testo statico.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Questo esclude il testo che è stato inserito dinamicamente dagli utenti.This excludes text that has been dynamically input by users.

-Quando il modello di espressione regolare è stato testato accuratamente per assicurarsi che gestisca in modo efficiente le corrispondenze, non corrispondenze e quasi corrispondenze.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Vedi anche

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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

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.The string to search for a match.

beginning
Int32

Posizione del carattere in base zero nella stringa di input che definisce la posizione più a sinistra in cui cercare.The zero-based character position in the input string that defines the leftmost position to be searched.

length
Int32

Numero di caratteri nella sottostringa da includere nella ricerca.The number of characters in the substring to include in the search.

Restituisce

Oggetto contenente informazioni sulla corrispondenza.An object that contains information about the match.

Eccezioni

input è null.input is null.

beginning è minore di zero o maggiore della lunghezza di input.beginning is less than zero or greater than the length of input.

-oppure--or- length è minore di zero o maggiore della lunghezza di input.length is less than zero or greater than the length of input.

-oppure--or- beginning+length-1 identifica una posizione esterna all'intervallo di input.beginning+length-1 identifies a position that is outside the range of input.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

Il Match(String, Int32, Int32) metodo restituisce la prima sottostringa corrispondente a un criterio di espressione regolare in una parte di una stringa di input.The Match(String, Int32, Int32) method returns the first substring that matches a regular expression pattern in a portion of an input string. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.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 Match(String, Int32, Int32) quale il metodo esegue la ricerca viene definito dalla chiamata a Regex uno dei costruttori della classe.The regular expression pattern for which the Match(String, Int32, Int32) method searches is defined by the call to one of the Regex class constructors. Per altre informazioni sugli elementi che possono formare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Il Match(String, Int32, Int32) metodo esegue la ricerca della input parte di definita beginning dai length parametri e per il criterio di espressione regolare.The Match(String, Int32, Int32) method searches the portion of input defined by the beginning and length parameters for the regular expression pattern. beginningdefinisce sempre l'indice del carattere più a sinistra da includere nella ricerca e length definisce il numero massimo di caratteri da cercare.beginning always defines the index of the leftmost character to include in the search, and length defines the maximum number of characters to search. Insieme definiscono l'intervallo della ricerca.Together, they define the range of the search. Se la ricerca procede da sinistra a destra (impostazione predefinita), il motore delle espressioni regolari esegue la ricerca dal carattere in beginning corrispondenza dell'indice al carattere beginning in corrispondenza dell'indice + length 1.If the search proceeds from left to right (the default), the regular expression engine searches from the character at index beginning to the character at index beginning + length - 1. Se è stata creata un'istanza del motore delle espressioni regolari RegexOptions.RightToLeft usando l'opzione in modo che la ricerca proceda da destra a sinistra, il motore delle espressioni regolari Cerca dal carattere beginning in corrispondenza dell'indice + length 1 al carattere in corrispondenza beginningdell'indice.If the regular expression engine was instantiated by using the RegexOptions.RightToLeft option so that the search proceeds from right to left, the regular expression engine searches from the character at index beginning + length - 1 to the character at index beginning. Questo metodo restituisce la prima corrispondenza trovata all'interno di questo intervallo.This method returns the first match that it finds within this range. È possibile recuperare le corrispondenze successive chiamando ripetutamente Match il Match.NextMatch metodo dell'oggetto restituito.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method.

È possibile determinare se il modello di espressione regolare è stato trovato nella stringa di input controllando il valore della Match Success proprietà dell'oggetto restituito.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se viene trovata una corrispondenza, la Match Value proprietà dell'oggetto restituito contiene la sottostringa input da che corrisponde al criterio di espressione regolare.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se non viene trovata alcuna corrispondenza, il relativo String.Emptyvalore è.If no match is found, its value is String.Empty.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato Regex.Regex(String, RegexOptions, TimeSpan) dal costruttore.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Se non si imposta un valore di timeout quando si chiama il costruttore, viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l' Regex oggetto.If you do not set a time-out value when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio dell'applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Vedi anche

Match(String, String, RegexOptions)

Cerca nella stringa di input la prima occorrenza dell'espressione regolare specificata usando le opzioni di corrispondenza specificate.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

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.The string to search for a match.

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.A bitwise combination of the enumeration values that provide options for matching.

Restituisce

Oggetto contenente informazioni sulla corrispondenza.An object that contains information about the match.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

input o pattern è null.input or pattern is null.

options non è una combinazione bit per bit valida di valori di RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Esempi

Nell'esempio seguente viene definita un'espressione regolare che corrisponde a parole che iniziano con la lettera "a".The following example defines a regular expression that matches words beginning with the letter "a". Usa l' RegexOptions.IgnoreCase opzione per garantire che l'espressione regolare trovi parole che iniziano con una "a" maiuscola e una "a" minuscola.It uses the RegexOptions.IgnoreCase option to ensure that the regular expression locates words beginning with both an uppercase "a" and a lowercase "a".

using System;
using System.Text.RegularExpressions;

public class Example
{
   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.The regular expression pattern \ba\w*\b is interpreted as shown in the following table.

ModelloPattern DescriptionDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
a Corrisponde al carattere "a".Match the character "a".
\w* Corrisponde a zero, uno o più caratteri alfanumerici.Match zero, one, or more word characters.
\b Termina la corrispondenza sul confine di parola.End the match at a word boundary.

Commenti

Il Match(String, String, RegexOptions) metodo restituisce la prima sottostringa corrispondente a un criterio di espressione regolare in una stringa di input.The Match(String, String, RegexOptions) method returns the first substring that matches a regular expression pattern in an input string. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il metodo Match(String, String, RegexOptions) statico equivale alla costruzione di un Regex oggetto con il Regex(String, RegexOptions) costruttore e alla chiamata del metodo Match(String) di istanza.The static Match(String, String, RegexOptions) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions) constructor and calling the instance Match(String) method.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

È possibile determinare se il modello di espressione regolare è stato trovato nella stringa di input controllando il valore della Match Success proprietà dell'oggetto restituito.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se viene trovata una corrispondenza, la Match Value proprietà dell'oggetto restituito contiene la sottostringa input da che corrisponde al criterio di espressione regolare.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se non viene trovata alcuna corrispondenza, il relativo String.Emptyvalore è.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa trovata input in che corrisponde al criterio di espressione regolare.This method returns the first substring found in input that matches the regular expression pattern. È possibile recuperare le corrispondenze successive chiamando ripetutamente Match il NextMatch metodo dell'oggetto restituito.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo Regex.Matches(String, String, RegexOptions) chiamando il metodo.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Note per i chiamanti

Si verifica il timeout di questo metodo dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Se non è stato definito un valore di timeout per il dominio dell'applicazione, viene usato InfiniteMatchTimeoutil valore, che impedisce il timeout del metodo.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Il metodo statico consigliato per il recupero di una corrispondenza del Match(String, String)criterio è, che consente di impostare l'intervallo di timeout.The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

Vedi anche

Match(String, Int32)

Cerca nella stringa di input la prima occorrenza di un'espressione regolare, a partire dalla posizione iniziale specificata nella stringa.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

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.The string to search for a match.

startat
Int32

Posizione del carattere in base zero dalla quale iniziare la ricerca.The zero-based character position at which to start the search.

Restituisce

Oggetto contenente informazioni sulla corrispondenza.An object that contains information about the match.

Eccezioni

input è null.input is null.

startat è minore di zero o maggiore della lunghezza di input.startat is less than zero or greater than the length of input.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

Il Match(String, Int32) metodo restituisce la prima sottostringa corrispondente a un criterio di espressione regolare, a partire da startat o dopo la posizione del carattere, in una stringa di input.The Match(String, Int32) method returns the first substring that matches a regular expression pattern, starting at or after the startat character position, in an input string. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.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 Match(String, Int32) quale il metodo esegue la ricerca viene definito dalla chiamata a Regex uno dei costruttori della classe.The regular expression pattern for which the Match(String, Int32) method searches is defined by the call to one of the Regex class constructors. Per altre informazioni sugli elementi che possono formare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Facoltativamente, è possibile specificare una posizione iniziale nella stringa utilizzando il startat parametro.You can optionally specify a starting position in the string by using the startat parameter. Quando il motore delle espressioni regolari analizza da sinistra a destra (impostazione predefinita), la corrispondenza e l'analisi spostano spostamenti, a partire dal carattere specificato startatin.When the regular expression engine parses from left to right (the default), the match and the scan move rightward, starting at the character specified in startat. Quando il motore delle espressioni regolari analizza da destra a sinistra (quando il criterio di espressione regolare viene costruito con RegexOptions.RightToLeft l'opzione), la corrispondenza e l'analisi si spostano nella direzione opposta e iniziano startat con il carattere a-1.When the regular expression engine parses from right to left (when the regular expression pattern is constructed with the RegexOptions.RightToLeft option), the match and scan move in the opposite direction and begin with the character at startat -1. Se non si specifica una posizione iniziale, la ricerca inizia in corrispondenza della posizione startat predefinita.If you do not specify a starting position, the search begins at the default startat position. Se l'espressione regolare effettua la ricerca da sinistra a destra, startat la posizione predefinita si trova all'estremità inputsinistra di; se esegue la ricerca da destra a sinistra startat , la posizione predefinita si trova all' inputestremità destra di.If the regular expression searches from left to right, the default startat position is at the left end of input; if it searches from right to left, the default startat position is at the right end of input.

Se si vuole limitare una corrispondenza in modo che inizi in corrispondenza di una determinata posizione del carattere nella stringa e il motore delle espressioni regolari non analizza il resto della stringa per trovare una corrispondenza, ancorare l'espressione regolare \G con un oggetto (a sinistra per un oggetto da sinistra a destra). pattern o a destra per uno schema da destra a sinistra.If you want to restrict a match so that it begins at a particular character position in the string and the regular expression engine does not scan the remainder of the string for a match, anchor the regular expression with a \G (at the left for a left-to-right pattern, or at the right for a right-to-left pattern). In questo modo si limita la corrispondenza, in modo che venga startatavviata esattamente in.This restricts the match so it must start exactly at startat.

È possibile determinare se il modello di espressione regolare è stato trovato nella stringa di input controllando il valore della Match Success proprietà dell'oggetto restituito.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se viene trovata una corrispondenza, la Match Value proprietà dell'oggetto restituito contiene la sottostringa input da che corrisponde al criterio di espressione regolare.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se non viene trovata alcuna corrispondenza, il relativo String.Emptyvalore è.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa trovata in corrispondenza o startat dopo la posizione input del carattere in che corrisponde al criterio di espressione regolare.This method returns the first substring found at or after the startat character position in input that matches the regular expression pattern. È possibile recuperare le corrispondenze successive chiamando ripetutamente Match il Match.NextMatch metodo dell'oggetto restituito.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo Regex.Matches(String, Int32) chiamando il metodo.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, Int32) method.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato Regex.Regex(String, RegexOptions, TimeSpan) dal costruttore.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l' Regex oggetto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio dell'applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Vedi anche

Match(String)

Cerca nella stringa di input specificata la prima ricorrenza dell'espressione regolare specificata nel costruttore Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

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.The string to search for a match.

Restituisce

Oggetto contenente informazioni sulla corrispondenza.An object that contains information about the match.

Eccezioni

input è null.input is null.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Esempi

Nell'esempio seguente vengono individuate le corrispondenze dei criteri di ricerca di espressioni regolari in una stringa, quindi vengono elencati i gruppi, le acquisizioni e le posizioni di acquisizione corrispondenti.The following example finds regular expression pattern matches in a string, then lists the matched groups, captures, and capture positions.

#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 trova la corrispondenza con le occorrenze della parola "Car" insieme alla parola che la precede.The regular expression pattern (\w+)\s+(car) matches occurrences of the word "car" along with the word that precedes it. Viene interpretato come illustrato nella tabella seguente.It is interpreted as shown in the following table.

ModelloPattern DescriptionDescription
(\w+) Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\s+ Corrisponde a uno o più spazi vuoti.Match one or more white-space characters.
auto(car) Corrisponde alla stringa letterale "Car".Match the literal string "car". Equivale al secondo gruppo di acquisizione.This is the second capturing group.

Commenti

Il Match(String) metodo restituisce la prima sottostringa corrispondente a un criterio di espressione regolare in una stringa di input.The Match(String) method returns the first substring that matches a regular expression pattern in an input string. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

È possibile determinare se il modello di espressione regolare è stato trovato nella stringa di input controllando il valore della Match Success proprietà dell'oggetto restituito.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se viene trovata una corrispondenza, la Match Value proprietà dell'oggetto restituito contiene la sottostringa input da che corrisponde al criterio di espressione regolare.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se non viene trovata alcuna corrispondenza, il relativo String.Emptyvalore è.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa input in che corrisponde al criterio di espressione regolare.This method returns the first substring in input that matches the regular expression pattern. È possibile recuperare le corrispondenze successive chiamando ripetutamente Match il Match.NextMatch metodo dell'oggetto restituito.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo Regex.Matches(String) chiamando il metodo.You can also retrieve all matches in a single method call by calling the Regex.Matches(String) method.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato Regex.Regex(String, RegexOptions, TimeSpan) dal costruttore.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l' Regex oggetto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio dell'applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Vedi anche

Match(String, String)

Cerca nella stringa di input specificata la prima occorrenza dell'espressione regolare specificata.Searches the specified input string for the first occurrence of the specified regular expression.

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.The string to search for a match.

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

Restituisce

Oggetto contenente informazioni sulla corrispondenza.An object that contains information about the match.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

input o pattern è null.input or pattern is null.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Esempi

Nell'esempio seguente viene chiamato Match(String, String) il metodo per trovare la prima parola che contiene almeno un z carattere e quindi viene chiamato il Match.NextMatch metodo per trovare eventuali corrispondenze aggiuntive.The following example calls the Match(String, String) method to find the first word that contains at least one z character, and then calls the Match.NextMatch method to find any additional matches.

using System;
using System.Text.RegularExpressions;

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.The regular expression pattern \b\w*z+\w*\b is interpreted as shown in the following table.

ModelloPattern DescriptionDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
\w* Corrisponde a zero, uno o più caratteri alfanumerici.Match zero, one, or more word characters.
z+ Corrisponde a una o più occorrenze del z carattere.Match one or more occurrences of the z character.
\w* Corrisponde a zero, uno o più caratteri alfanumerici.Match zero, one, or more word characters.
\b Termina la corrispondenza sul confine di parola.End the match at a word boundary.

Commenti

Il Match(String, String) metodo restituisce la prima sottostringa corrispondente a un criterio di espressione regolare in una stringa di input.The Match(String, String) method returns the first substring that matches a regular expression pattern in an input string. Per informazioni sugli elementi del linguaggio usati per compilare un modello di espressione regolare, vedere linguaggio di espressioni regolari-riferimento rapido.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Il metodo Match(String, String) statico equivale alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e alla chiamata del Match(String) metodo di istanza.The static Match(String, String) method is equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance Match(String) method. In questo caso, il motore delle espressioni regolari memorizza nella cache il modello di espressione regolare.In this case, the regular expression engine caches the regular expression pattern.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

È possibile determinare se il modello di espressione regolare è stato trovato nella stringa di input controllando il valore della Match Success proprietà dell'oggetto restituito.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se viene trovata una corrispondenza, la Match Value proprietà dell'oggetto restituito contiene la sottostringa input da che corrisponde al criterio di espressione regolare.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se non viene trovata alcuna corrispondenza, il relativo String.Emptyvalore è.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa input in che corrisponde al criterio di espressione regolare.This method returns the first substring in input that matches the regular expression pattern. È possibile recuperare le corrispondenze successive chiamando ripetutamente Match il Match.NextMatch metodo dell'oggetto restituito.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo Regex.Matches(String, String) chiamando il metodo.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String) method.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Note per i chiamanti

Si verifica il timeout di questo metodo dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Se non è stato definito un valore di timeout per il dominio dell'applicazione, viene usato InfiniteMatchTimeoutil valore, che impedisce il timeout del metodo.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Il metodo statico consigliato per il recupero di una corrispondenza del Match(String, String)criterio è, che consente di impostare l'intervallo di timeout.The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

Vedi anche

Si applica a