Regex.IsMatch Metodo

Definizione

Spazio dei nomi:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Indica se l'espressione regolare trova una corrispondenza nella stringa di input.

Overload

IsMatch(String, String, RegexOptions, TimeSpan)	Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata, utilizzando le opzioni di corrispondenza specificate e l'intervallo di timeout.
IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)	Indica se l'espressione regolare specificata trova una corrispondenza nell'intervallo di input specificato, utilizzando le opzioni di corrispondenza specificate e l'intervallo di timeout.
IsMatch(String, String, RegexOptions)	Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata, utilizzando le opzioni di corrispondenza specificate.
IsMatch(ReadOnlySpan<Char>, String, RegexOptions)	Indica se l'espressione regolare specificata trova una corrispondenza nell'intervallo di input specificato, utilizzando le opzioni di corrispondenza specificate.
IsMatch(String, String)	Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata.
IsMatch(ReadOnlySpan<Char>, Int32)	Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in un intervallo di input specificato.
IsMatch(ReadOnlySpan<Char>, String)	Indica se l'espressione regolare specificata trova una corrispondenza nell'intervallo di input specificato.
IsMatch(String, Int32)	Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza nella stringa di input specificata, a partire dalla posizione iniziale specificata nella stringa.
IsMatch(String)	Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in una stringa di input specificata.
IsMatch(ReadOnlySpan<Char>)	Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in un intervallo di input specificato.

IsMatch(String, String, RegexOptions, TimeSpan)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata, utilizzando le opzioni di corrispondenza specificate e l'intervallo di timeout.

C#

public static bool IsMatch (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

Parametri

input

String

Stringa in cui cercare una corrispondenza.

pattern

String

Modello di espressione regolare da trovare in corrispondenza.

options

RegexOptions

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

matchTimeout

TimeSpan

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

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

options non è un valore di RegexOptions valido.

-o-

matchTimeout è negativo, zero o maggiore di circa 24 giorni.

RegexMatchTimeoutException

Si è verificato un timeout.

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo IsMatch(String, String, RegexOptions, TimeSpan) per determinare se una stringa è un numero di parte valido. L'espressione regolare presuppone che il numero di parte abbia un formato specifico costituito da tre set di caratteri separati da trattini. Il primo set, che contiene quattro caratteri, deve essere costituito da un carattere alfanumerico seguito da due caratteri numerici seguiti da un carattere alfanumerico. Il secondo set, costituito da tre caratteri, deve essere numerico. Il terzo set, costituito da quattro caratteri, deve avere tre caratteri numerici seguiti da un carattere alfanumerico. La corrispondenza del criterio di espressione regolare deve comportare una ricerca minima nella stringa di input, quindi il metodo imposta un intervallo di timeout di 500 millisecondi.

C#

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468a",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
foreach (string partNumber in partNumbers)
    try
    {
        bool isMatch = Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(500));
        Console.WriteLine($"{partNumber} {(isMatch ? "is" : "is not")} a valid part number.");
    }
    catch (RegexMatchTimeoutException e)
    {
        Console.WriteLine($"Timeout after {e.MatchTimeout} seconds matching {e.Input}.");
    }

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Il criterio di espressione regolare è:

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Modello	Descrizione
^	Iniziare la corrispondenza all'inizio della stringa.
[A-Z0-9]	Trova la corrispondenza con qualsiasi carattere alfabetico di A tramite Zo qualsiasi carattere numerico.
\d{2}	Trova la corrispondenza con due caratteri numerici.
[A-Z0-9]	Trova la corrispondenza con qualsiasi carattere alfabetico di A tramite Zo qualsiasi carattere numerico.
-	Trova la corrispondenza con un trattino.
\d{3}	Trova la corrispondenza con tre caratteri numerici.
(-\d{3}){2}	Trovare un trattino seguito da tre caratteri numerici e trovare due occorrenze di questo modello.
[A-Z0-9]	Trova la corrispondenza con qualsiasi carattere alfabetico di A tramite Zo qualsiasi carattere numerico.
$	Terminare la corrispondenza alla fine della stringa.

La chiamata al metodo IsMatch(String, String, RegexOptions, TimeSpan) con il parametro options impostato su RegexOptions.IgnoreCase equivale a definire l'espressione regolare seguente:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]

Per un confronto, vedere l'esempio per il metodo IsMatch(String, String).

Commenti

Il metodo IsMatch viene in genere usato per convalidare una stringa o per assicurarsi che una stringa sia conforme a un modello specifico senza recuperare tale stringa per la successiva manipolazione. Se si desidera determinare se una o più stringhe corrispondono a un criterio di espressione regolare e quindi recuperarle per la modifica successiva, chiamare il metodo Match o Matches.

Il metodo IsMatch(String, String, RegexOptions, TimeSpan) statico equivale a costruire un oggetto Regex con il criterio di espressione regolare specificato da pattern e le opzioni di espressione regolare specificate da options e chiamando il metodo dell'istanza di IsMatch(String). Questo modello di espressione regolare viene memorizzato nella cache per il recupero rapido dal motore delle espressioni regolari.

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

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

Note per i chiamanti

È consigliabile impostare il parametro matchTimeout su un valore appropriato, ad esempio due secondi. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore delle espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:

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

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

• Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.

Vedi anche

• elementi del linguaggio delle espressioni regolari

IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata trova una corrispondenza nell'intervallo di input specificato, utilizzando le opzioni di corrispondenza specificate e l'intervallo di timeout.

C#

public static bool IsMatch (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

Parametri

input

ReadOnlySpan<Char>

Intervallo in cui cercare una corrispondenza.

pattern

String

Modello di espressione regolare da trovare in corrispondenza.

options

RegexOptions

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

matchTimeout

TimeSpan

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

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

pattern è null

RegexMatchTimeoutException

Si è verificato un timeout.

ArgumentOutOfRangeException

options non è in un valore di RegexOptions valido o matchTimeout è negativo, zero o maggiore di circa 24 giorni.

IsMatch(String, String, RegexOptions)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata, utilizzando le opzioni di corrispondenza specificate.

C#

public static bool IsMatch (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

Parametri

input

String

Stringa in cui cercare una corrispondenza.

pattern

String

Modello di espressione regolare da trovare in corrispondenza.

options

RegexOptions

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

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

options non è un valore di RegexOptions valido.

RegexMatchTimeoutException

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

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo IsMatch(String, String) per determinare se una stringa è un numero di parte valido. L'espressione regolare presuppone che il numero di parte abbia un formato specifico costituito da tre set di caratteri separati da trattini. Il primo set, che contiene quattro caratteri, deve essere costituito da un carattere alfanumerico seguito da due caratteri numerici seguiti da un carattere alfanumerico. Il secondo set, costituito da tre caratteri, deve essere numerico. Il terzo set, costituito da quattro caratteri, deve avere tre caratteri numerici seguiti da un carattere alfanumerico.

C#

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468a",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
foreach (string partNumber in partNumbers)
    Console.WriteLine("{0} {1} a valid part number.",
                      partNumber,
                      Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase) ? "is" : "is not");

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Il criterio di espressione regolare è:

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Modello	Descrizione
^	Iniziare la corrispondenza all'inizio della stringa.
[A-Z0-9]	Trova la corrispondenza con qualsiasi carattere alfabetico di A tramite Zo qualsiasi carattere numerico.
\d{2}	Trova la corrispondenza con due caratteri numerici.
[A-Z0-9]	Trova la corrispondenza con qualsiasi carattere alfabetico di A tramite Zo qualsiasi carattere numerico.
-	Trova la corrispondenza con un trattino.
\d{3}	Trova la corrispondenza con tre caratteri numerici.
(-\d{3}){2}	Trovare un trattino seguito da tre caratteri numerici e trovare due occorrenze di questo criterio.
[A-Z0-9]	Trova la corrispondenza con qualsiasi carattere alfabetico di A tramite Zo qualsiasi carattere numerico.
$	Terminare la corrispondenza alla fine della stringa.

La chiamata al metodo IsMatch(String, String, RegexOptions) con il parametro options impostato su RegexOptions.IgnoreCase equivale a definire l'espressione regolare seguente:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]

Per un confronto, vedere l'esempio per il metodo IsMatch(String, String).

Commenti

Il metodo IsMatch viene in genere usato per convalidare una stringa o per assicurarsi che una stringa sia conforme a un modello specifico senza recuperare tale stringa per la successiva manipolazione. Se si desidera determinare se una o più stringhe corrispondono a un criterio di espressione regolare e quindi recuperarle per la modifica successiva, chiamare il metodo Match o Matches.

Il metodo IsMatch(String, String, RegexOptions) statico equivale a costruire un oggetto Regex con il criterio di espressione regolare specificato da pattern e le opzioni di espressione regolare specificate da options e chiamando il metodo dell'istanza di IsMatch(String). Questo modello di espressione regolare viene memorizzato nella cache per il recupero rapido dal motore delle espressioni regolari.

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

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

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato. Se non è stato definito un valore di timeout per il dominio applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per verificare una corrispondenza del criterio è IsMatch(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

Vedi anche

• elementi del linguaggio delle espressioni regolari

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata trova una corrispondenza nell'intervallo di input specificato, utilizzando le opzioni di corrispondenza specificate.

C#

public static bool IsMatch (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options);

Parametri

input

ReadOnlySpan<Char>

Intervallo in cui cercare una corrispondenza.

pattern

String

Modello di espressione regolare da trovare in corrispondenza.

options

RegexOptions

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

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

pattern è null

RegexMatchTimeoutException

Si è verificato un timeout.

ArgumentOutOfRangeException

options non è in un valore di RegexOptions valido.

IsMatch(String, String)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata trova una corrispondenza nella stringa di input specificata.

C#

public static bool IsMatch (string input, string pattern);

Parametri

input

String

Stringa in cui cercare una corrispondenza.

pattern

String

Modello di espressione regolare da trovare in corrispondenza.

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

RegexMatchTimeoutException

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

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo IsMatch(String, String) per determinare se una stringa è un numero di parte valido. L'espressione regolare presuppone che il numero di parte abbia un formato specifico costituito da tre set di caratteri separati da trattini. Il primo set, che contiene quattro caratteri, deve essere costituito da un carattere alfanumerico seguito da due caratteri numerici seguiti da un carattere alfanumerico. Il secondo set, costituito da tre caratteri, deve essere numerico. Il terzo set, costituito da quattro caratteri, deve avere tre caratteri numerici seguiti da un carattere alfanumerico.

C#

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468A",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
string pattern = @"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$";
foreach (string partNumber in partNumbers)
    Console.WriteLine($"{partNumber} {(Regex.IsMatch(partNumber, pattern) ? "is" : "is not")} " +
        $"a valid part number.");

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Il criterio di espressione regolare è:

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Modello	Descrizione
^	Iniziare la corrispondenza all'inizio della riga.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
\d{2}	Trova la corrispondenza con due caratteri numerici.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
-	Trova la corrispondenza con un trattino.
\d{3}	Trova la corrispondenza con tre caratteri numerici.
(-\d{3}){2}	Trovare un trattino seguito da tre caratteri numerici e trovare due occorrenze di questo modello.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
$	Terminare la corrispondenza alla fine della riga.

Commenti

Il metodo IsMatch viene in genere usato per convalidare una stringa o per assicurarsi che una stringa sia conforme a un modello specifico senza recuperare tale stringa per la successiva manipolazione. Se si desidera determinare se una o più stringhe corrispondono a un criterio di espressione regolare e quindi recuperarle per la modifica successiva, chiamare il metodo Match o Matches.

Il metodo IsMatch(String, String) statico equivale a costruire un oggetto Regex con il criterio di espressione regolare specificato da pattern e chiamando il metodo di istanza IsMatch(String). Questo modello di espressione regolare viene memorizzato nella cache per il recupero rapido dal motore delle espressioni regolari.

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

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

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato il metodo . Se non è stato definito un valore di timeout per il dominio applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per verificare una corrispondenza del criterio è IsMatch(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

Vedi anche

• elementi del linguaggio delle espressioni regolari

IsMatch(ReadOnlySpan<Char>, Int32)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in un intervallo di input specificato.

C#

public bool IsMatch (ReadOnlySpan<char> input, int startat);

Parametri

input

ReadOnlySpan<Char>

Intervallo in cui cercare una corrispondenza.

startat

Int32

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

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

RegexMatchTimeoutException

Si è verificato un timeout.

IsMatch(ReadOnlySpan<Char>, String)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata trova una corrispondenza nell'intervallo di input specificato.

C#

public static bool IsMatch (ReadOnlySpan<char> input, string pattern);

Parametri

input

ReadOnlySpan<Char>

Intervallo in cui cercare una corrispondenza.

pattern

String

Modello di espressione regolare da trovare in corrispondenza.

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

pattern è null

RegexMatchTimeoutException

Si è verificato un timeout.

IsMatch(String, Int32)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza nella stringa di input specificata, a partire dalla posizione iniziale specificata nella stringa.

C#

public bool IsMatch (string input, int startat);

Parametri

input

String

Stringa in cui cercare una corrispondenza.

startat

Int32

Posizione del carattere in corrispondenza della quale avviare la ricerca.

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentNullException

input è null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo IsMatch(String, Int32) per determinare se una stringa è un numero di parte valido. Cerca un numero di parte che segue due punti (:) carattere in una stringa. Il metodo IndexOf(Char) viene utilizzato per determinare la posizione del carattere due punti, che viene quindi passato al metodo IsMatch(String, Int32). L'espressione regolare presuppone che il numero di parte abbia un formato specifico costituito da tre set di caratteri separati da trattini. Il primo set, che contiene quattro caratteri, deve essere costituito da un carattere alfanumerico seguito da due caratteri numerici seguiti da un carattere alfanumerico. Il secondo set, costituito da tre caratteri, deve essere numerico. Il terzo set, costituito da quattro caratteri, deve avere tre caratteri numerici seguiti da un carattere alfanumerico.

C#

string[] partNumbers = [ "Part Number: 1298-673-4192", "Part No: A08Z-931-468A",
                      "_A90-123-129X", "123K-000-1230",
                      "SKU: 0919-2893-1256" ];
Regex rgx = MyRegex();
foreach (string partNumber in partNumbers)
{
    int start = partNumber.IndexOf(':');
    if (start >= 0)
    {
        Console.WriteLine($"{partNumber} {(rgx.IsMatch(partNumber, start) ? "is" : "is not")} a valid part number.");
    }
    else
    {
        Console.WriteLine("Cannot find starting position in {0}.", partNumber);
    }
}

// The example displays the following output:
//       Part Number: 1298-673-4192 is a valid part number.
//       Part No: A08Z-931-468A is a valid part number.
//       Cannot find starting position in _A90-123-129X.
//       Cannot find starting position in 123K-000-1230.
//       SKU: 0919-2893-1256 is not a valid part number.

Il criterio di espressione regolare è:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Modello	Descrizione
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
\d{2}	Trova la corrispondenza con due caratteri numerici.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
-	Trova la corrispondenza con un trattino.
\d{3}	Trova la corrispondenza con tre caratteri numerici.
(-\d{3}){2}	Trovare un trattino seguito da tre caratteri numerici e trovare due occorrenze di questo modello.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
$	Terminare la corrispondenza alla fine della riga.

Commenti

Il metodo IsMatch viene in genere usato per convalidare una stringa o per assicurarsi che una stringa sia conforme a un modello specifico senza recuperare tale stringa per la successiva manipolazione. Se si desidera determinare se una o più stringhe corrispondono a un criterio di espressione regolare e quindi recuperarle per la modifica successiva, chiamare il metodo Match o Matches.

Per altre informazioni su startat, vedere la sezione Osservazioni di Match(String, Int32).

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

Vedi anche

• elementi del linguaggio delle espressioni regolari

IsMatch(String)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in una stringa di input specificata.

C#

public bool IsMatch (string input);

Parametri

input

String

Stringa in cui cercare una corrispondenza.

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

ArgumentNullException

input è null.

RegexMatchTimeoutException

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

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo IsMatch(String) per determinare se una stringa è un numero di parte valido. L'espressione regolare presuppone che il numero di parte abbia un formato specifico costituito da tre set di caratteri separati da trattini. Il primo set, che contiene quattro caratteri, deve essere costituito da un carattere alfanumerico seguito da due caratteri numerici seguiti da un carattere alfanumerico. Il secondo set, costituito da tre caratteri, deve essere numerico. Il terzo set, costituito da quattro caratteri, deve avere tre caratteri numerici seguiti da un carattere alfanumerico.

C#

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468A",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
Regex rgx = new Regex(@"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$");
foreach (string partNumber in partNumbers)
    Console.WriteLine($"{partNumber} {(rgx.IsMatch(partNumber) ? "is" : "is not")} a valid part number.");

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Il criterio di espressione regolare è:

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Modello	Descrizione
^	Iniziare la corrispondenza all'inizio della riga.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
\d{2}	Trova la corrispondenza con due caratteri numerici.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
-	Trova la corrispondenza con un trattino.
\d{3}	Trova la corrispondenza con tre caratteri numerici.
(-\d{3}){2}	Trovare un trattino seguito da tre caratteri numerici e trovare due occorrenze di questo modello.
[a-zA-Z0-9]	Trova la corrispondenza con un singolo carattere alfabetico (a tramite z o A tramite Z) o un carattere numerico.
$	Terminare la corrispondenza alla fine della riga.

Commenti

Il metodo IsMatch viene in genere usato per convalidare una stringa o per assicurarsi che una stringa sia conforme a un modello specifico senza recuperare tale stringa per la successiva manipolazione. Se si desidera determinare se una o più stringhe corrispondono a un criterio di espressione regolare e quindi recuperarle per la modifica successiva, chiamare il metodo Match o Matches.

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

Vedi anche

• elementi del linguaggio delle espressioni regolari

IsMatch(ReadOnlySpan<Char>)

Origine:

Regex.Match.cs

Indica se l'espressione regolare specificata nel costruttore Regex trova una corrispondenza in un intervallo di input specificato.

C#

public bool IsMatch (ReadOnlySpan<char> input);

Parametri

input

ReadOnlySpan<Char>

Intervallo in cui cercare una corrispondenza.

Restituisce

Boolean

true se l'espressione regolare trova una corrispondenza; in caso contrario, false.

Eccezioni

RegexMatchTimeoutException

Si è verificato un timeout.