RegexSmith
Espressioni regolari spiegate e testate proprio dove vengono scritte. Passa il mouse su un pattern in C# per vedere una riga per ogni parte in parole semplici, i gruppi a colori e stringhe che corrispondono; vedi sottolineati i pattern che possono bloccarsi; prova i tuoi esempi nel Tester RegexSmith e riscrivi il pattern nel codice con un clic.
Gratuito · Visual Studio 2022 e 2026 · 14 lingue dell’interfaccia · nessuna telemetria
Perché RegexSmith
![Una scheda al passaggio del mouse su un pattern [GeneratedRegex]: il pattern con i gruppi colorati, una riga per ogni parte in parole semplici, esempi che corrispondono e uno che non corrisponde, e lo stato ✓ sicuro](../../regexsmith/marketplace/hero.png)
Parole semplici, non una lezione di sintassi
^(?<year>\d{4})-(?<id>\d{1,5})$ diventa «Inizio del testo», «Esattamente 4 cifre», «Da 1 a 5 cifre» — una riga per ogni parte, annidata sotto il suo gruppo, ogni gruppo con il proprio colore.
Verificato dal vero motore
Gli esempi nella scheda e ogni risultato nel tester provengono dal motore regex di .NET stesso, con le opzioni della chiamata. Quello che vedi è quello che farà la tua app.
Pattern che possono bloccarsi
([a-z0-9]+\.?)+ sembra innocuo e può bloccare una richiesta su una stringa lunga che quasi corrisponde. RegexSmith sottolinea queste ripetizioni e le corregge con Ctrl+.
Gratuito, senza vincoli
Nessun abbonamento, nessuna versione «pro», nessuna raccolta di dati, nessun messaggio nella finestra Output o all’avvio. Pattern ed esempi restano sul tuo computer. L’unica cosa che ti chiederemo — dopo che l’avrai usata per un po’ — è una valutazione sul Marketplace. Funziona con Visual Studio 2022 e 2026, x64 e ARM64.
Funzionalità
- La scheda al passaggio del mouse su un pattern in C#: il pattern con i gruppi colorati, una riga per ogni parte in parole semplici, etichette dei gruppi colorate e uno stato — ✓ sicuro, ⚠ può bloccarsi o ✕ non valido.
- Sottolineature dei gruppi: una linea sottile del colore del gruppo sotto ogni gruppo di cattura, direttamente nel codice; i gruppi annidati stanno più in basso.
- Esempi ricavati dal pattern — due stringhe che corrispondono e una che non corrisponde — verificati dal vero motore di .NET.
- RX001: una sottolineatura ondulata sotto le ripetizioni che possono richiedere un tempo esponenziale, con correzioni in Ctrl+. e un’anteprima prima/dopo.
- Il Tester RegexSmith, ancorato accanto a Risultati ricerca: i tuoi esempi con aspettative ✓/✗, corrispondenze e gruppi evidenziati, una tabella dei gruppi e una scheda Sostituisci.
- Applica al codice: il pattern modificato torna nello stesso tipo di stringa letterale, con le sue opzioni, come un unico Annulla.
- Copia come unit test per xUnit, NUnit o MSTest — i tuoi esempi diventano casi di test.
La scheda al passaggio del mouse
Passa il mouse sulla stringa di un pattern e la normale descrizione comando di Visual Studio riceve una scheda di RegexSmith: cosa significa il pattern, cosa trova e se è sicuro.

Dove funziona
Nei file C#, sul pattern di:
new Regex("…"), con o senzaRegexOptions;- i metodi statici
Regex.IsMatch,Match,Matches,Replace,SpliteCount; [GeneratedRegex("…")];[RegularExpression("…")]— la scheda indica allora Convalida: deve corrispondere l'intero valore;- una
const stringnello stesso file usata da uno di questi.
Le stringhe normali, verbatim (@"…") e raw ("""…""") vengono lette come le legge il compilatore, quindi "\\d" e @"\d" sono lo stesso pattern.
Cosa mostra la scheda
| Sullo schermo | Significato |
|---|---|
| RegexSmith · Espressione regolare .NET · IgnoreCase | Il tipo di pattern e le opzioni lette dalla chiamata, e lo stato a destra. |
| Il pattern | Le parentesi di ogni gruppo di cattura nel suo colore, il contenuto sottolineato in quel colore; il testo mantiene il colore del tema, così resta leggibile. |
| Esattamente 4 cifre | Una riga per ogni parte in parole semplici — «Inizio del testo», «Uno dei testi: “jpg”, “png”», «Da 1 a 5 cifre» — annidata sotto il suo gruppo. Un pattern molto lungo termina con … altre N. |
| Etichette dei gruppi | Il nome o il numero di ogni gruppo su un’etichetta nel suo colore — gli stessi colori del pattern e del codice. |
| ✓ Corrisponde: … ✗ Non corrisponde: … | Due stringhe che corrispondono e una che non corrisponde, ricavate dal pattern e verificate dal vero motore di .NET. Gli spazi appaiono come puntini tenui. |
| ▶ Testa il modello… | Apre il pattern nel Tester RegexSmith. |
Lo stato
| Sullo schermo | Significato |
|---|---|
| ✓ sicuro | .NET accetta il pattern e nulla al suo interno può causare un backtracking catastrofico. |
| ⚠ può bloccarsi | Una ripetizione può richiedere un tempo esponenziale su un input lungo che quasi corrisponde; la scheda indica di che tipo (RX001) e che Ctrl+. offre delle correzioni. |
| ✕ non valido | Il motore rifiuta il pattern; la scheda mostra il suo messaggio: .NET non accetta questo modello: … |
«Sicuro» significa solo questo: .NET accetta il pattern e non può bloccarsi. Non significa che trovi ciò che intendi — a questo servono gli esempi e il tester.
Sottolineature dei gruppi
Ogni gruppo di cattura di un pattern riceve una linea sottile del suo colore direttamente nel codice — lo stesso colore della scheda. Un pattern lungo con cinque gruppi si legge a colpo d’occhio: quale parte è l’anno, quale l’id.
Un gruppo dentro un altro sta un po’ più in basso, così entrambe le linee restano visibili. I colori seguono quest’ordine: salmone, verde, blu, viola, ambra, verde acqua — e di nuovo.
Le sottolineature si possono disattivare nelle impostazioni: Sottolinea i gruppi di acquisizione.
Pattern che possono bloccarsi
Alcuni pattern richiedono un tempo esponenziale su una stringa lunga che quasi corrisponde — il classico modo in cui una regex blocca una richiesta web. RegexSmith li riconosce dalla loro forma e mette una sottolineatura ondulata di avviso sotto la ripetizione; passaci sopra con il mouse per conoscerne il motivo.
![Una sottolineatura ondulata RX001 sotto ([a-z0-9]+\.?)+ con il menu Ctrl+. aperto e un’anteprima della correzione: il vecchio pattern barrato, il nuovo con un gruppo atomico](../../regexsmith/marketplace/backtracking.png)
Cosa viene sottolineato (RX001)
- Ripetizione annidata:
(a+)+,([a-z0-9]+\.?)+— una sequenza degli stessi caratteri può essere divisa tra la ripetizione interna e quella esterna in moltissimi modi. - Ripetizione di alternative che corrispondono agli stessi caratteri:
(\w|\d)+— una cifra può essere presa da entrambi i rami, quindi ogni cifra raddoppia il lavoro.
Non all’interno di gruppi atomici o lookaround, e mai con RegexOptions.NonBacktracking — lì non può succedere.
Correzioni in Ctrl+.
Metti il cursore sulla sottolineatura ondulata e premi Ctrl+. — ogni correzione mostra un’anteprima: il pattern prima (barrato) e dopo.
| Correzione | Cosa fa |
|---|---|
| Rendi atomica la ripetizione interna: (?>…) | Racchiude la ripetizione interna in (?>…). Corrispondono le stesse stringhe; la ripetizione non può più essere suddivisa in molti modi. |
| Usa RegexOptions.NonBacktracking (.NET 7+) | Aggiunge l’opzione alla chiamata. Tempo lineare con qualsiasi input; richiede .NET 7 o versione successiva. Offerta solo quando il pattern lo consente — niente backreference, lookaround, gruppi atomici o di bilanciamento, condizionali. |
| Testa questo modello in RegexSmith | Apre il pattern nel tester — offerta su qualsiasi pattern, non solo su quelli a rischio. |
RX001 si può disattivare nelle impostazioni (Suggerimenti nell’editor) o con Non mostrare questo tipo di suggerimento nella sua descrizione comando; le correzioni in Ctrl+. restano.
Il tester
Il Tester RegexSmith si apre ancorato accanto a Risultati ricerca. Il pattern proviene dal codice e resta collegato a esso: provalo sui tuoi esempi, modificalo e riscrivilo nel codice.

Come aprirlo
- ▶ Testa il modello… nella scheda al passaggio del mouse;
- Ctrl+. su un pattern › Testa questo modello in RegexSmith;
- clic destro in un file C# › Testa modello di espressione regolare;
- Visualizza › Altre finestre › Tester RegexSmith — non collegato al codice: un posto dove provare un pattern.
Il pattern e le sue opzioni
In alto, il file e la riga del pattern — fai clic per andarci. Sotto, la casella del pattern, la riga di stato (✓ sicuro, ⚠ può bloccarsi o l’errore del motore, poi N su M come previsto · ms) e i chip delle opzioni: IgnoreCase, Multiline, Singleline, IgnorePatternWhitespace, ExplicitCapture, RightToLeft, CultureInvariant. Ogni modifica viene eseguita di nuovo all’istante.
Esempi e aspettative
La prima volta ci sono gli esempi della scheda: due che dovrebbero corrispondere e uno che non dovrebbe. Digitane uno nuovo in Aggiungi un esempio e premi INVIO…; fai clic su un esempio per modificarlo, ✕ lo rimuove. Il segno prima di ogni esempio dice cosa dovrebbe fare — fai clic per cambiarlo:
| Sullo schermo | Significato |
|---|---|
| ✓ | deve corrispondere |
| ✗ | non deve corrispondere |
| – | nessuna aspettativa, solo mostra |
Un esempio che fa il contrario diventa rosso — ✗ corrisponde o ✗ nessuna corrispondenza — così gli esempi diventano una piccola specifica del pattern. Le corrispondenze sono evidenziate, i gruppi sottolineati nei loro colori, gli spazi mostrati come puntini. Un’esecuzione che dura più di 1 secondo si interrompe con ⏱ troppo lento.
Gruppi dell'esempio selezionato elenca ogni corrispondenza dell’esempio selezionato: la corrispondenza intera, poi ogni gruppo con il suo valore e la sua posizione (non acquisito quando non ha partecipato).
Sostituisci
La scheda Sostituisci aggiunge una casella di sostituzione — $1, ${name}, $$ per un $ — e mostra il risultato per ogni esempio, come farebbe Regex.Replace.
Copiare, ripristinare, applicare
Copia come unit test mette negli Appunti un test con i tuoi esempi, per xUnit, NUnit o MSTest — la specifica passa nel progetto di test.
Ripristina torna al pattern e alle opzioni del codice; gli esempi restano.
Applica al codice riscrive il pattern nello stesso tipo di letterale che era (normale, verbatim o raw) insieme alle opzioni — un solo Annulla lo riporta indietro. Se quel codice è cambiato dopo che il tester lo ha aperto, non viene scritto nulla: apri di nuovo il tester dal pattern.
Gli esempi vengono ricordati per pattern e per soluzione in %LocalAppData%\RegexSmith\samples, così la volta successiva sono già lì. Nulla finisce nel repository.
Impostazioni
Strumenti › Opzioni › SmithWorks › RegexSmith. Ogni opzione ha una breve descrizione di cosa fa.
| Opzione | Predefinito |
|---|---|
| Spiega i modelli al passaggio del mouse | attivo |
| Sottolinea i gruppi di acquisizione | attivo |
| RX001 Backtracking catastrofico | attivo |
| Chiedi una valutazione sul Marketplace | attivo |
In basso: Ripristina predefiniti, Documentazione, Valuta nel Marketplace e Invia feedback.
Le impostazioni sono salvate in %LocalAppData%\RegexSmith.

FAQ
RegexSmith invia dei dati?
No. I pattern vengono letti dal documento aperto ed eseguiti sul tuo computer; gli esempi sono conservati in %LocalAppData%\RegexSmith. Nessuna richiesta di rete, nessuna telemetria.
La scheda dice «✓ sicuro». Il pattern è corretto?
Non necessariamente. «Sicuro» significa che .NET accetta il pattern e che nessuna ripetizione al suo interno può causare un backtracking catastrofico. Se trova ciò che intendi lo devono mostrare gli esempi: contrassegnali con ✓ o ✗ nel tester.
Perché sul mio pattern non compare la scheda?
La scheda compare su una stringa letterale che RegexSmith sa essere un pattern: l’argomento di new Regex, di un metodo statico di Regex, di [GeneratedRegex] o di [RegularExpression], oppure una costante dello stesso file usata lì. Un pattern costruito in fase di esecuzione (concatenato, letto dalle impostazioni) non può essere letto. Verifica anche Spiega i modelli al passaggio del mouse nelle impostazioni.
Quale motore regex viene usato?
Il motore regex di .NET su cui gira Visual Studio stesso, con le opzioni della chiamata. Anche RegexOptions.NonBacktracking (.NET 7+) viene letto dalla chiamata; gli esempi vengono allora eseguiti sul motore abituale, e le stringhe che corrispondono sono le stesse in entrambi i casi.
Applica al codice non ha fatto nulla.
Il codice del pattern è cambiato dopo che il tester lo ha aperto, quindi RegexSmith non scrive in un punto che potrebbe non contenere più il pattern — il tester lo segnala sotto i pulsanti. Apri di nuovo il tester dal pattern. Dove il codice non ha posto per le opzioni ([RegularExpression] non ne accetta), il pattern viene scritto e le opzioni no.
Funziona in VB.NET, JavaScript o TypeScript?
Non nella 1.0: solo C#. Altri linguaggi usano altri motori; chiedi nel repository Feedback se te ne serve uno.
Dove posso segnalare un problema o suggerire una funzionalità?
Apri una issue nel repository Feedback su GitHub: ci sono moduli per bug e idee (cambia i nomi privati). Puoi anche usare la scheda Q&A nel Marketplace.
Registro modifiche
1.0.1
- I suggerimenti nell’editor hanno un proprio elenco nella pagina delle opzioni e un collegamento nella descrizione comando disattiva un tipo di suggerimento proprio dove lo vedi.
1.0.0
- Prima versione: la scheda al passaggio del mouse con una scomposizione in parole semplici, gruppi colorati, esempi verificati dal motore di .NET e uno stato; le sottolineature dei gruppi nel codice; RX001 per i pattern che possono bloccarsi, con correzioni atomiche e NonBacktracking in Ctrl+.; il Tester RegexSmith con aspettative, gruppi, Sostituisci, Copia come unit test e Applica al codice; una sola richiesta di valutazione.