Regex.Match Regex.Match Regex.Match Regex.Match Method

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) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) 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) Match(String, Int32, Int32) Match(String, Int32, Int32) 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) Match(String, String, RegexOptions) Match(String, String, RegexOptions) 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) Match(String, Int32) Match(String, Int32) 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) Match(String) Match(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) Match(String, String) Match(String, String) 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) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) 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 String String String

Stringa nella quale cercare una corrispondenza.The string to search for a match.

pattern
String String String String

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

options
RegexOptions RegexOptions RegexOptions 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 TimeSpan TimeSpan 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.

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 statico Match(String, String, RegexOptions, TimeSpan) metodo è equivalente alla costruzione di un Regex dell'oggetto con il Regex(String, RegexOptions, TimeSpan) costruttore e chiamare l'istanza Match(String) (metodo).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 di linguaggio di espressioni regolari che descrivono in modo univoco la stringa da confrontare.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per altre informazioni sulle espressioni regolari, vedere espressioni regolari di .NET Framework 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 criterio di espressione regolare è stato trovato nella stringa di input controllando il valore dell'oggetto restituito Match dell'oggetto Success proprietà.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, l'oggetto restituito Match dell'oggetto Value proprietà contiene la sottostringa da input 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 viene trovata alcuna corrispondenza, il relativo valore è String.Empty.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa trovata input 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 restituito ripetutamente Match dell'oggetto NextMatch (metodo).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 chiamando il Regex.Matches(String, String, RegexOptions) (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 il modo in cui lungo un modello corrispondente metodo deve effettuare per trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce le espressioni regolari che si basano su un backtracking eccessivo che venga visualizzato il blocco quando elaborano un input che contiene corrispondenze.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 Backtracking.For more information, see Best Practices for Regular Expressions and Backtracking. Se viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo genera un RegexMatchTimeoutException eccezione.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio 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

È consigliabile 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 disabilita 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, è necessario disabilitare i timeout solo nelle condizioni seguenti:However, you should disable time-outs only under the following conditions: -Quando l'input elaborata da un'espressione regolare è derivato da un'origine conosciuta e attendibile o è 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. Esclude il testo che è stato in modo dinamico inseriti dagli utenti.This excludes text that has been dynamically input by users.

-Quando il criterio di espressione regolare è stata accuratamente testato per verificare che gestisca in modo efficiente trova, mancate corrispondenze e a breve.- 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 alcun elemento di linguaggio che potrebbero causare un backtracking eccessivo durante l'elaborazione di una corrispondenza più vicino.- 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) Match(String, Int32, Int32) Match(String, Int32, Int32) 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 String String String

Stringa nella quale cercare una corrispondenza.The string to search for a match.

beginning
Int32 Int32 Int32 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 Int32 Int32 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

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

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

In alternativa-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.

Criterio di espressione regolare per cui il Match(String, Int32, Int32) ricerche metodo è definito dalla chiamata a uno del Regex 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) Cerca la parte del input definiti dal beginning e length parametri 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. beginning sempre definisce 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 (predefinito), il motore delle espressioni regolari Cerca dal carattere in corrispondenza dell'indice beginning per il carattere in corrispondenza dell'indice beginning + 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 il motore delle espressioni regolari è stato creato usando il RegexOptions.RightToLeft opzione, in modo che la ricerca procede da destra a sinistra, le ricerche di motore di espressioni regolari tra il carattere in corrispondenza dell'indice beginning + length - 1 per il carattere in corrispondenza dell'indice beginning.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 restituito ripetutamente Match dell'oggetto Match.NextMatch (metodo).You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore dell'oggetto restituito Match dell'oggetto Success proprietà.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, l'oggetto restituito Match dell'oggetto Value proprietà contiene la sottostringa da input 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 viene trovata alcuna corrispondenza, il relativo valore è String.Empty.If no match is found, its value is String.Empty.

Il RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato da di Regex.Regex(String, RegexOptions, TimeSpan) 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, l'eccezione viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio applicazione in cui il Regex oggetto viene creato.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 è impostato alcun timeout non definito nel Regex chiamata al costruttore o nelle proprietà del dominio dell'applicazione, o se il valore di timeout è Regex.InfiniteMatchTimeout, 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) Match(String, String, RegexOptions) Match(String, String, RegexOptions) 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 String String String

Stringa nella quale cercare una corrispondenza.The string to search for a match.

pattern
String String String String

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

options
RegexOptions RegexOptions RegexOptions 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.

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

L'esempio seguente definisce 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 il RegexOptions.IgnoreCase opzione per assicurarsi che l'espressione regolare individua parole che iniziano con entrambi maiuscolo minuscolo di "a" e a "a".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 DescrizioneDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
a Corrispondenza con il 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 statico Match(String, String, RegexOptions) metodo è equivalente alla costruzione di un Regex dell'oggetto con il Regex(String, RegexOptions) costruttore e chiamare l'istanza Match(String) (metodo).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 di linguaggio di espressioni regolari che descrivono in modo univoco la stringa da confrontare.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per altre informazioni sulle espressioni regolari, vedere espressioni regolari di .NET Framework 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 criterio di espressione regolare è stato trovato nella stringa di input controllando il valore dell'oggetto restituito Match dell'oggetto Success proprietà.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, l'oggetto restituito Match dell'oggetto Value proprietà contiene la sottostringa da input 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 viene trovata alcuna corrispondenza, il relativo valore è String.Empty.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa trovata input 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 restituito ripetutamente Match dell'oggetto NextMatch (metodo).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 chiamando il Regex.Matches(String, String, RegexOptions) (metodo).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

Il 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 è impostato alcun timeout non viene definito nelle proprietà del dominio dell'applicazione, o se il valore di timeout è Regex.InfiniteMatchTimeout, 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

Questo metodo verifica il timeout 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, il valore InfiniteMatchTimeout, timeout, che impedisce il metodo viene utilizzato.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 un criterio di ricerca è Match(String, String), 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) Match(String, Int32) Match(String, Int32) 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 String String String

Stringa nella quale cercare una corrispondenza.The string to search for a match.

startat
Int32 Int32 Int32 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

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, partire o dopo il startat 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.

Criterio di espressione regolare per cui il Match(String, Int32) ricerche metodo è definito dalla chiamata a uno del Regex 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 usando 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 (predefinito), la corrispondenza e l'analisi di spostamento verso destra, iniziando in corrispondenza del carattere specificato in startat.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 la RegexOptions.RightToLeft opzione), la corrispondenza e l'analisi sposta nella direzione opposta e iniziare con il carattere alla startat -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 il valore predefinito startat posizione.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, il valore predefinito startat si trova in fondo a sinistra input; se esegue la ricerca da destra a sinistra, il valore predefinito startat si trova all'estremità destra della input.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 desidera limitare una corrispondenza in modo che inizi da una posizione particolare carattere nella stringa e il motore delle espressioni regolari non esegue la scansione il resto della stringa per trovare una corrispondenza, agganciare l'espressione regolare con una \G (a sinistra per un da sinistra a destra modello o a destra per un modello di right-to-left).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). Questo limita la corrispondenza in modo che abbia inizio esattamente da startat.This restricts the match so it must start exactly at startat.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore dell'oggetto restituito Match dell'oggetto Success proprietà.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, l'oggetto restituito Match dell'oggetto Value proprietà contiene la sottostringa da input 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 viene trovata alcuna corrispondenza, il relativo valore è String.Empty.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa trovata o dopo il startat posizione del carattere in input 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 restituito ripetutamente Match dell'oggetto Match.NextMatch (metodo).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 chiamando il Regex.Matches(String, Int32) (metodo).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, Int32) method.

Il RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato da di Regex.Regex(String, RegexOptions, TimeSpan) 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, l'eccezione viene generata se l'operazione supera un valore di timeout stabilito per il dominio applicazione in cui il Regex oggetto viene creato.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 è impostato alcun timeout non definito nel Regex chiamata al costruttore o nelle proprietà del dominio dell'applicazione, o se il valore di timeout è Regex.InfiniteMatchTimeout, 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) Match(String) Match(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.

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 String String 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

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 consente di trovare modello di espressione regolare corrisponde a una stringa, viene fornito l'elenco corrispondente gruppi, le acquisizioni e le posizioni di acquisizione.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

Criterio di espressione regolare (\w+)\s+(car) le occorrenze della parola "car" contenente la 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 DescrizioneDescription
(\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ù caratteri spazio vuoto.Match one or more white-space characters.
(Auto)(car) Corrisponde alla stringa letterale "automobile".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 criterio di espressione regolare è stato trovato nella stringa di input controllando il valore dell'oggetto restituito Match dell'oggetto Success proprietà.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, l'oggetto restituito Match dell'oggetto Value proprietà contiene la sottostringa da input 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 viene trovata alcuna corrispondenza, il relativo valore è String.Empty.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa nella input 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 restituito ripetutamente Match dell'oggetto Match.NextMatch (metodo).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 chiamando il Regex.Matches(String) (metodo).You can also retrieve all matches in a single method call by calling the Regex.Matches(String) method.

Il RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di corrispondenza supera l'intervallo di timeout specificato da di Regex.Regex(String, RegexOptions, TimeSpan) 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, l'eccezione viene generata se l'operazione supera un valore di timeout stabilito per il dominio applicazione in cui il Regex oggetto viene creato.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 è impostato alcun timeout non definito nel Regex chiamata al costruttore o nelle proprietà del dominio dell'applicazione, o se il valore di timeout è Regex.InfiniteMatchTimeout, 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) Match(String, String) Match(String, String) 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 String String String

Stringa nella quale cercare una corrispondenza.The string to search for a match.

pattern
String String String 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.

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

L'esempio seguente chiama il Match(String, String) metodo per trovare la prima parola che contiene almeno uno z carattere e quindi chiama il Match.NextMatch metodo per trovare altre corrispondenze.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 DescrizioneDescription
\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+ Trova la corrispondenza 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 statico Match(String, String) metodo è equivalente alla costruzione di un Regex con il modello di espressione regolare specificata dell'oggetto e chiamare l'istanza Match(String) (metodo).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 criterio di espressione regolare.In this case, the regular expression engine caches the regular expression pattern.

Il pattern parametro è costituito da elementi di linguaggio di espressioni regolari che descrivono in modo univoco la stringa da confrontare.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per altre informazioni sulle espressioni regolari, vedere espressioni regolari di .NET Framework 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 criterio di espressione regolare è stato trovato nella stringa di input controllando il valore dell'oggetto restituito Match dell'oggetto Success proprietà.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, l'oggetto restituito Match dell'oggetto Value proprietà contiene la sottostringa da input 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 viene trovata alcuna corrispondenza, il relativo valore è String.Empty.If no match is found, its value is String.Empty.

Questo metodo restituisce la prima sottostringa nella input 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 restituito ripetutamente Match dell'oggetto Match.NextMatch (metodo).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 chiamando il Regex.Matches(String, String) (metodo).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String) method.

Il 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 è impostato alcun timeout non viene definito nelle proprietà del dominio dell'applicazione, o se il valore di timeout è Regex.InfiniteMatchTimeout, 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

Questo metodo verifica il timeout 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, il valore InfiniteMatchTimeout, timeout, che impedisce il metodo viene utilizzato.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 un criterio di ricerca è Match(String, String), 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