Regex.Replace Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
In una stringa di input specificata, sostituisce le stringhe corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
Overload
Replace(String, MatchEvaluator, Int32, Int32) |
In una sottostringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa restituita da un delegato MatchEvaluator. |
Replace(String, String, String) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. |
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) |
In una stringa di input specificata, sostituisce tutte le sottostringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza. |
Replace(String, String, MatchEvaluator, RegexOptions) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. Le opzioni specificate modificano l'operazione di corrispondenza. |
Replace(String, String, String, RegexOptions, TimeSpan) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza. |
Replace(String, String, String, RegexOptions) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. Le opzioni specificate modificano l'operazione di corrispondenza. |
Replace(String, MatchEvaluator) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. |
Replace(String, MatchEvaluator, Int32) |
In una stringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa restituita da un delegato MatchEvaluator. |
Replace(String, String, MatchEvaluator) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. |
Replace(String, String, Int32) |
In una stringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata. |
Replace(String, String) |
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata. |
Replace(String, String, Int32, Int32) |
In una sottostringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata. |
Replace(String, MatchEvaluator, Int32, Int32)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una sottostringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa restituita da un delegato MatchEvaluator.
public:
System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string
Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- evaluator
- MatchEvaluator
Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.
- count
- Int32
Numero massimo di volte in cui la sostituzione avrà luogo.
- startat
- Int32
Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.
Restituisce
Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
input
o evaluator
è null
.
startat
è minore di zero o maggiore della lunghezza di input
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
Il Regex.Replace(String, MatchEvaluator, Int32, Int32) metodo è utile per sostituire una corrispondenza di espressione regolare se una delle condizioni seguenti è true:
- La stringa di sostituzione non può essere facilmente specificata da un modello di sostituzione dell'espressione regolare.
- La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.
- La stringa di sostituzione risulta dall'elaborazione condizionale.
Il metodo equivale a chiamare il Regex.Matches(String, Int32) metodo e passare i primiMatchcount
oggetti nella raccolta restituita MatchCollection al evaluator
delegato.
Per altre informazioni su startat
, vedere la sezione Osservazioni di Match(String, Int32).
L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .
Il evaluator
parametro è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al MatchEvaluator delegato.
public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String
Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata l'eccezione se l'operazione supera qualsiasi valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato eventuali sostituzioni alla stringa di input.
Vedi anche
- MatchEvaluator
- Sostituzioni nelle espressioni regolari
- Linguaggio di espressioni regolari - Riferimento rapido
Si applica a
Replace(String, String, String)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata.
public:
static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);
public static string Replace (string input, string pattern, string replacement);
static member Replace : string * string * string -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- replacement
- String
Stringa di sostituzione.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se pattern
non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
, pattern
o replacement
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene definita un'espressione regolare, che \s+
corrisponde a uno o più caratteri di spazio vuoto. La stringa di sostituzione , " ", li sostituisce con un singolo carattere di spazio.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is text with far too much " +
"white space.";
string pattern = "\\s+";
string replacement = " ";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine("Original String: {0}", input);
Console.WriteLine("Replacement String: {0}", result);
}
}
// The example displays the following output:
// Original String: This is text with far too much white space.
// Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is text with far too much " + _
"white space."
Dim pattern As String = "\s+"
Dim replacement As String = " "
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine("Original String: {0}", input)
Console.WriteLine("Replacement String: {0}", result)
End Sub
End Module
' The example displays the following output:
' Original String: This is text with far too much white space.
' Replacement String: This is text with far too much white space.
Nell'esempio seguente viene usato il Replace(String, String, String) metodo per sostituire il computer locale e i nomi di unità in un percorso UNC con un percorso file locale. L'espressione regolare usa la Environment.MachineName proprietà per includere il nome del computer locale e il Environment.GetLogicalDrives metodo per includere i nomi delle unità logiche. Per eseguire correttamente l'esempio, è necessario sostituire la stringa letterale "MyMachine" con il nome del computer locale.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Get drives available on local computer and form into a single character expression.
string[] drives = Environment.GetLogicalDrives();
string driveNames = String.Empty;
foreach (string drive in drives)
driveNames += drive.Substring(0,1);
// Create regular expression pattern dynamically based on local machine information.
string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";
string replacement = "$1:";
string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt",
@"\\MyMachine\c$\ThingsToDo.txt",
@"\\MyMachine\d$\documents\mydocument.docx" };
foreach (string uncPath in uncPaths)
{
Console.WriteLine("Input string: " + uncPath);
Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
Console.WriteLine();
}
}
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
// Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
// Returned string: C:\ThingsToDo.txt
//
// Input string: \\MyMachine\c$\ThingsToDo.txt
// Returned string: c:\ThingsToDo.txt
//
// Input string: \\MyMachine\d$\documents\mydocument.docx
// Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Get drives available on local computer and form into a single character expression.
Dim drives() As String = Environment.GetLogicalDrives()
Dim driveNames As String = Nothing
For Each drive As String In drives
driveNames += drive.Substring(0,1)
Next
' Create regular expression pattern dynamically based on local machine information.
Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"
Dim replacement As String = "$1:"
Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
"\\MyMachine\c$\ThingsToDo.txt", _
"\\MyMachine\d$\documents\mydocument.docx" }
For Each uncPath As String In uncPaths
Console.WriteLine("Input string: " + uncPath)
Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
' Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
' Returned string: C:\ThingsToDo.txt
'
' Input string: \\MyMachine\c$\ThingsToDo.txt
' Returned string: c:\ThingsToDo.txt
'
' Input string: \\MyMachine\d$\documents\mydocument.docx
' Returned string: d:\documents\mydocument.docx
Il modello di espressione regolare è definito dall'espressione seguente:
"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"
Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.
Modello | Descrizione |
---|---|
\\\\ |
Trovare una corrispondenza tra due caratteri rovesciata consecutivi (\ ). Poiché il carattere barra rovesciata viene interpretato come carattere di escape, ogni barra rovesciata deve essere escape con un'altra barra rovesciata. |
(?i:" + Environment.MachineName + ") |
Eseguire una corrispondenza senza distinzione tra maiuscole e minuscole della stringa restituita dalla Environment.MachineName proprietà . |
(?:\.\w+)* |
Corrisponde al carattere (. ) seguito da uno o più caratteri di parola. Questa corrispondenza può verificarsi zero o più volte. La sottoespressione corrispondente non viene acquisita. |
\\ |
Corrisponde a un carattere barra rovesciata (\ ). |
((?i:[" + driveNames + "])) |
Eseguire una corrispondenza senza distinzione tra maiuscole e minuscole della classe carattere costituita dalle singole lettere di unità. Questa corrispondenza è la prima sottoespressione acquisita. |
\$ |
Corrisponde al carattere del dollaro letterale ($ ). |
Il modello $1
di sostituzione sostituisce l'intera corrispondenza con la prima sottoespressione acquisita. Vale a dire, sostituisce il computer UNC e il nome dell'unità con la lettera di unità.
Commenti
I metodi statici Replace
sono equivalenti alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e la chiamata al metodo Replace
di istanza .
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressione regolare - Riferimento rapido. La ricerca delle corrispondenze inizia all'inizio input
della stringa.
Il replacement
parametro specifica la stringa che consiste nel sostituire ogni corrispondenza in input
. replacement
può essere costituita da qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il criterio a*${test}b
di sostituzione inserisce la stringa "a*" seguita dalla sottostringa corrispondente al test
gruppo di acquisizione, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.
Nota
Le sostituzioni sono gli unici elementi del linguaggio delle espressioni regolari riconosciuti in un criterio di sostituzione. Tutti gli altri elementi del linguaggio delle espressioni regolari, inclusi i caratteri di escape, sono consentiti solo nei modelli di espressione regolare e non vengono riconosciuti nei modelli di sostituzione.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato per il dominio dell'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.
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
Note per i chiamanti
Questo metodo viene eseguito il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato. Se un valore di timeout non è stato definito per il dominio dell'applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per sostituire una corrispondenza modello è Replace(String, String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.
Vedi anche
Si applica a
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le sottostringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.
public:
static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- evaluator
- MatchEvaluator
Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.
- matchTimeout
- TimeSpan
Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se pattern
non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
, pattern
o evaluator
è null
.
options
non è una combinazione bit per bit valida di valori di RegexOptions.
-oppure-
matchTimeout
è negativo, zero o maggiore di circa 24 giorni.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre le singole parole da una stringa e quindi viene utilizzato un delegato per chiamare un MatchEvaluator metodo denominato WordScramble
che esegue lo scramble delle singole lettere nella parola. A tale scopo, il WordScramble
metodo crea una matrice contenente i caratteri nella corrispondenza. Crea anche una matrice parallela che popola con numeri a virgola mobile casuali. Le matrici vengono ordinate chiamando il Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metodo e la matrice ordinata viene fornita come argomento a un String costruttore di classe. Questa stringa appena creata viene quindi restituita dal WordScramble
metodo . Il criterio \w+
di espressione regolare corrisponde a uno o più caratteri di parola. Il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza finché non rileva un carattere non di parola, ad esempio uno spazio vuoto. La chiamata al Replace(String, String, MatchEvaluator, RegexOptions) metodo include l'opzione RegexOptions.IgnorePatternWhitespace in modo che il commento nel criterio \w+ # Matches all the characters in a word.
di espressione regolare venga ignorato dal motore delle espressioni regolari.
using System;
using System.Collections;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string words = "letter alphabetical missing lack release " +
"penchant slack acryllic laundry cease";
string pattern = @"\w+ # Matches all the characters in a word.";
MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
Console.WriteLine("Original words:");
Console.WriteLine(words);
Console.WriteLine();
try {
Console.WriteLine("Scrambled words:");
Console.WriteLine(Regex.Replace(words, pattern, evaluator,
RegexOptions.IgnorePatternWhitespace,
TimeSpan.FromSeconds(.25)));
}
catch (RegexMatchTimeoutException) {
Console.WriteLine("Word Scramble operation timed out.");
Console.WriteLine("Returned words:");
}
}
public static string WordScrambler(Match match)
{
int arraySize = match.Value.Length;
// Define two arrays equal to the number of letters in the match.
double[] keys = new double[arraySize];
char[] letters = new char[arraySize];
// Instantiate random number generator'
Random rnd = new Random();
for (int ctr = 0; ctr < match.Value.Length; ctr++)
{
// Populate the array of keys with random numbers.
keys[ctr] = rnd.NextDouble();
// Assign letter to array of letters.
letters[ctr] = match.Value[ctr];
}
Array.Sort(keys, letters, 0, arraySize, Comparer.Default);
return new String(letters);
}
}
// The example displays output similar to the following:
// Original words:
// letter alphabetical missing lack release penchant slack acryllic laundry cease
//
// Scrambled words:
// etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim words As String = "letter alphabetical missing lack release " + _
"penchant slack acryllic laundry cease"
Dim pattern As String = "\w+ # Matches all the characters in a word."
Dim evaluator As MatchEvaluator = AddressOf WordScrambler
Console.WriteLine("Original words:")
Console.WriteLine(words)
Try
Console.WriteLine("Scrambled words:")
Console.WriteLine(Regex.Replace(words, pattern, evaluator,
RegexOptions.IgnorePatternWhitespace,
TimeSpan.FromSeconds(.25)))
Catch e As RegexMatchTimeoutException
Console.WriteLine("Word Scramble operation timed out.")
Console.WriteLine("Returned words:")
End Try
End Sub
Public Function WordScrambler(match As Match) As String
Dim arraySize As Integer = match.Value.Length - 1
' Define two arrays equal to the number of letters in the match.
Dim keys(arraySize) As Double
Dim letters(arraySize) As Char
' Instantiate random number generator'
Dim rnd As New Random()
For ctr As Integer = 0 To match.Value.Length - 1
' Populate the array of keys with random numbers.
keys(ctr) = rnd.NextDouble()
' Assign letter to array of letters.
letters(ctr) = match.Value.Chars(ctr)
Next
Array.Sort(keys, letters, 0, arraySize, Comparer.Default)
Return New String(letters)
End Function
End Module
' The example displays output similar to the following:
' Original words:
' letter alphabetical missing lack release penchant slack acryllic laundry cease
'
' Scrambled words:
' etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Commenti
Il Regex.Replace(String, String, MatchEvaluator, RegexOptions) metodo è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:
Se la stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione delle espressioni regolari.
Se la stringa di sostituzione deriva da un'elaborazione eseguita sulla stringa corrispondente.
Se la stringa di sostituzione risulta dall'elaborazione condizionale.
Il metodo equivale a chiamare il Regex.Matches(String, String, RegexOptions) metodo e a passare ogni Match oggetto nella raccolta restituita MatchCollection al evaluator
delegato.
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.
Il evaluator
parametro è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Per trovare la corrispondenza con il MatchEvaluator delegato, il metodo personalizzato deve avere la firma seguente.
public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String
Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.
Se si specifica RightToLeft per il options
parametro , la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.
Il matchTimeout
parametro specifica per quanto tempo un metodo di corrispondenza dei criteri deve tentare di 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 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 dell'applicazione in cui viene eseguito il metodo.
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
Note per i chiamanti
È consigliabile impostare il matchTimeout
parametro 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. Esclude il testo 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
- RegexOptions
- Sostituzioni nelle espressioni regolari
- Elementi del linguaggio di espressioni regolari
- Backtracking nelle espressioni regolari
- Procedure consigliate per le espressioni regolari in .NET
Si applica a
Replace(String, String, MatchEvaluator, RegexOptions)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator. Le opzioni specificate modificano l'operazione di corrispondenza.
public:
static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- evaluator
- MatchEvaluator
Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.
Restituisce
Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione. Se pattern
non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
, pattern
o evaluator
è null
.
options
non è una combinazione bit per bit valida di valori di RegexOptions.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre le singole parole da una stringa e quindi viene utilizzato un delegato per chiamare un MatchEvaluator metodo denominato WordScramble
che esegue lo scramble delle singole lettere nella parola. A tale scopo, il WordScramble
metodo crea una matrice contenente i caratteri nella corrispondenza. Crea anche una matrice parallela che popola con numeri a virgola mobile casuali. Le matrici vengono ordinate chiamando il Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metodo e la matrice ordinata viene fornita come argomento a un String costruttore di classe. Questa stringa appena creata viene quindi restituita dal WordScramble
metodo . Il criterio \w+
di espressione regolare corrisponde a uno o più caratteri di parola. Il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza finché non rileva un carattere non di parola, ad esempio uno spazio vuoto. La chiamata al Replace(String, String, MatchEvaluator, RegexOptions) metodo include l'opzione RegexOptions.IgnorePatternWhitespace in modo che il commento nel criterio \w+ # Matches all the characters in a word.
di espressione regolare venga ignorato dal motore delle espressioni regolari.
using System;
using System.Collections;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string words = "letter alphabetical missing lack release " +
"penchant slack acryllic laundry cease";
string pattern = @"\w+ # Matches all the characters in a word.";
MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
Console.WriteLine("Original words:");
Console.WriteLine(words);
Console.WriteLine();
Console.WriteLine("Scrambled words:");
Console.WriteLine(Regex.Replace(words, pattern, evaluator,
RegexOptions.IgnorePatternWhitespace));
}
public static string WordScrambler(Match match)
{
int arraySize = match.Value.Length;
// Define two arrays equal to the number of letters in the match.
double[] keys = new double[arraySize];
char[] letters = new char[arraySize];
// Instantiate random number generator'
Random rnd = new Random();
for (int ctr = 0; ctr < match.Value.Length; ctr++)
{
// Populate the array of keys with random numbers.
keys[ctr] = rnd.NextDouble();
// Assign letter to array of letters.
letters[ctr] = match.Value[ctr];
}
Array.Sort(keys, letters, 0, arraySize, Comparer.Default);
return new String(letters);
}
}
// The example displays output similar to the following:
// Original words:
// letter alphabetical missing lack release penchant slack acryllic laundry cease
//
// Scrambled words:
// etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim words As String = "letter alphabetical missing lack release " + _
"penchant slack acryllic laundry cease"
Dim pattern As String = "\w+ # Matches all the characters in a word."
Dim evaluator As MatchEvaluator = AddressOf WordScrambler
Console.WriteLine("Original words:")
Console.WriteLine(words)
Console.WriteLine("Scrambled words:")
Console.WriteLine(Regex.Replace(words, pattern, evaluator,
RegexOptions.IgnorePatternWhitespace))
End Sub
Public Function WordScrambler(match As Match) As String
Dim arraySize As Integer = match.Value.Length - 1
' Define two arrays equal to the number of letters in the match.
Dim keys(arraySize) As Double
Dim letters(arraySize) As Char
' Instantiate random number generator'
Dim rnd As New Random()
For ctr As Integer = 0 To match.Value.Length - 1
' Populate the array of keys with random numbers.
keys(ctr) = rnd.NextDouble()
' Assign letter to array of letters.
letters(ctr) = match.Value.Chars(ctr)
Next
Array.Sort(keys, letters, 0, arraySize, Comparer.Default)
Return New String(letters)
End Function
End Module
' The example displays output similar to the following:
' Original words:
' letter alphabetical missing lack release penchant slack acryllic laundry cease
'
' Scrambled words:
' etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Commenti
Il Regex.Replace(String, String, MatchEvaluator, RegexOptions) metodo è utile per sostituire una corrispondenza di un'espressione regolare in se una delle condizioni seguenti è vera:
La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione dell'espressione regolare.
La stringa di sostituzione deriva da un'elaborazione eseguita sulla stringa corrispondente.
La stringa di sostituzione deriva dall'elaborazione condizionale.
Il metodo equivale a chiamare il Regex.Matches(String, String, RegexOptions) metodo e a passare ogni Match oggetto nella raccolta restituita MatchCollection al evaluator
delegato.
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.
Il evaluator
parametro è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Per trovare la corrispondenza con il MatchEvaluator delegato, il metodo personalizzato deve avere la firma seguente.
public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String
Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.
Se si specifica RightToLeft per il options
parametro , la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato per il dominio dell'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.
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
Vedi anche
- MatchEvaluator
- RegexOptions
- Sostituzioni nelle espressioni regolari
- Elementi del linguaggio di espressioni regolari
Si applica a
Replace(String, String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.
public:
static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- replacement
- String
Stringa di sostituzione.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.
- matchTimeout
- TimeSpan
Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se pattern
non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
, pattern
o replacement
è null
.
options
non è una combinazione bit per bit valida di valori di RegexOptions.
-oppure-
matchTimeout
è negativo, zero o maggiore di circa 24 giorni.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene usato il Replace(String, String, String, RegexOptions, TimeSpan) metodo per sostituire il computer locale e i nomi di unità in un percorso UNC con un percorso di file locale. L'espressione regolare usa la Environment.MachineName proprietà per includere il nome del computer locale e il Environment.GetLogicalDrives metodo per includere i nomi delle unità logiche. Tutti i confronti tra stringhe di espressioni regolari non fanno distinzione tra maiuscole e minuscole e si verifica un timeout di qualsiasi singola operazione di sostituzione se non è possibile trovare una corrispondenza in 0,5 secondi. Per eseguire correttamente l'esempio, è necessario sostituire la stringa letterale "MyMachine" con il nome del computer locale.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Get drives available on local computer and form into a single character expression.
string[] drives = Environment.GetLogicalDrives();
string driveNames = String.Empty;
foreach (string drive in drives)
driveNames += drive.Substring(0,1);
// Create regular expression pattern dynamically based on local machine information.
string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";
string replacement = "$1:";
string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt",
@"\\MyMachine\c$\ThingsToDo.txt",
@"\\MyMachine\d$\documents\mydocument.docx" };
foreach (string uncPath in uncPaths)
{
Console.WriteLine("Input string: " + uncPath);
string localPath = null;
try {
localPath = Regex.Replace(uncPath, pattern, replacement,
RegexOptions.IgnoreCase,
TimeSpan.FromSeconds(0.5));
Console.WriteLine("Returned string: " + localPath);
}
catch (RegexMatchTimeoutException) {
Console.WriteLine("The replace operation timed out.");
Console.WriteLine("Returned string: " + localPath);
if (uncPath.Equals(localPath))
Console.WriteLine("Equal to original path.");
else
Console.WriteLine("Original string: " + uncPath);
}
Console.WriteLine();
}
}
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
// Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
// Returned string: C:\ThingsToDo.txt
//
// Input string: \\MyMachine\c$\ThingsToDo.txt
// Returned string: c:\ThingsToDo.txt
//
// Input string: \\MyMachine\d$\documents\mydocument.docx
// Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Get drives available on local computer and form into a single character expression.
Dim drives() As String = Environment.GetLogicalDrives()
Dim driveNames As String = Nothing
For Each drive As String In drives
driveNames += drive.Substring(0,1)
Next
' Create regular expression pattern dynamically based on local machine information.
Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"
Dim replacement As String = "$1:"
Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
"\\MyMachine\c$\ThingsToDo.txt", _
"\\MyMachine\d$\documents\mydocument.docx" }
For Each uncPath As String In uncPaths
Console.WriteLine("Input string: " + uncPath)
Dim localPath As String = Nothing
Try
localPath = Regex.Replace(uncPath, pattern, replacement,
RegexOptions.IgnoreCase,
TimeSpan.FromSeconds(0.5))
Console.WriteLine("Returned string: " + localPath)
Catch e As RegexMatchTimeoutException
Console.WriteLine("The replace operation timed out.")
Console.WriteLine("Returned string: " + localPath)
If uncPath.Equals(localPath) Then
Console.WriteLine("Equal to original path.")
Else
Console.WriteLine("Original string: " + uncPath)
End If
End Try
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
' Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
' Returned string: C:\ThingsToDo.txt
'
' Input string: \\MyMachine\c$\ThingsToDo.txt
' Returned string: c:\ThingsToDo.txt
'
' Input string: \\MyMachine\d$\documents\mydocument.docx
' Returned string: d:\documents\mydocument.docx
Il criterio di espressione regolare è definito dall'espressione seguente:
"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"
Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.
Modello | Descrizione |
---|---|
\\\\ |
Trova la corrispondenza con due caratteri barra rovesciata consecutiva (\ ). Poiché il carattere barra rovesciata viene interpretato come carattere di escape, ogni barra rovesciata deve essere preceduta da un'altra barra rovesciata. |
+ Environment.MachineName + |
Trova la corrispondenza con la stringa restituita dalla Environment.MachineName proprietà . |
(?:\.\w+)* |
Trova la corrispondenza con il carattere punto (. ) seguito da uno o più caratteri di parola. Questa corrispondenza può verificarsi zero o più volte. La sottoespressione corrispondente non viene acquisita. |
\\ |
Trova la corrispondenza con una barra rovesciata (\ ). |
([" + driveNames + "]) |
Trova la corrispondenza con la classe di caratteri costituita dalle singole lettere di unità. Questa corrispondenza è la prima sottoespressione acquisita. |
\$ |
Trova la corrispondenza con il carattere del simbolo del dollaro letterale ($ ). |
Il modello $1
di sostituzione sostituisce l'intera corrispondenza con la prima sottoespressione acquisita. Ciò significa che sostituisce il computer UNC e il nome dell'unità con la lettera di unità.
Commenti
I metodi statici Replace
sono equivalenti alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e la chiamata al metodo Replace
di istanza .
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido. Se si specifica RightToLeft per il options
parametro , la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.
Il replacement
parametro specifica la stringa che deve sostituire ogni corrispondenza in input
. replacement
può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il criterio a*${test}b
di sostituzione inserisce la stringa "a*" seguita dalla sottostringa corrispondente al test
gruppo di acquisizione, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.
Nota
Le sostituzioni sono gli unici elementi del linguaggio delle espressioni regolari riconosciuti in un criterio di sostituzione. Tutti gli altri elementi del linguaggio delle espressioni regolari, inclusi i caratteri di escape, sono consentiti solo nei modelli di espressione regolare e non vengono riconosciuti nei modelli di sostituzione.
Il matchTimeout
parametro specifica per quanto tempo un metodo di corrispondenza dei criteri deve tentare di trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce la visualizzazione di espressioni regolari basate su un backtracking eccessivo per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere Procedure consigliate per 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 dell'applicazione in cui viene eseguito il metodo.
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
Note per i chiamanti
È consigliabile impostare il matchTimeout
parametro 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. Esclude il testo 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
- RegexOptions
- Sostituzioni nelle espressioni regolari
- Elementi del linguaggio di espressioni regolari
- Backtracking nelle espressioni regolari
- Procedure consigliate per le espressioni regolari in .NET
Si applica a
Replace(String, String, String, RegexOptions)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata. Le opzioni specificate modificano l'operazione di corrispondenza.
public:
static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);
public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);
static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- replacement
- String
Stringa di sostituzione.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se pattern
non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
, pattern
o replacement
è null
.
options
non è una combinazione bit per bit valida di valori di RegexOptions.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene usato il Replace(String, String, String, RegexOptions) metodo per sostituire il computer locale e i nomi di unità in un percorso UNC con un percorso di file locale. L'espressione regolare usa la Environment.MachineName proprietà per includere il nome del computer locale e il Environment.GetLogicalDrives metodo per includere i nomi delle unità logiche. Tutti i confronti tra stringhe di espressioni regolari non fanno distinzione tra maiuscole e minuscole. Per eseguire correttamente l'esempio, è necessario sostituire la stringa letterale "MyMachine" con il nome del computer locale.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Get drives available on local computer and form into a single character expression.
string[] drives = Environment.GetLogicalDrives();
string driveNames = String.Empty;
foreach (string drive in drives)
driveNames += drive.Substring(0,1);
// Create regular expression pattern dynamically based on local machine information.
string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";
string replacement = "$1:";
string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt",
@"\\MyMachine\c$\ThingsToDo.txt",
@"\\MyMachine\d$\documents\mydocument.docx" };
foreach (string uncPath in uncPaths)
{
Console.WriteLine("Input string: " + uncPath);
Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
Console.WriteLine();
}
}
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
// Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
// Returned string: C:\ThingsToDo.txt
//
// Input string: \\MyMachine\c$\ThingsToDo.txt
// Returned string: c:\ThingsToDo.txt
//
// Input string: \\MyMachine\d$\documents\mydocument.docx
// Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Get drives available on local computer and form into a single character expression.
Dim drives() As String = Environment.GetLogicalDrives()
Dim driveNames As String = Nothing
For Each drive As String In drives
driveNames += drive.Substring(0,1)
Next
' Create regular expression pattern dynamically based on local machine information.
Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"
Dim replacement As String = "$1:"
Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
"\\MyMachine\c$\ThingsToDo.txt", _
"\\MyMachine\d$\documents\mydocument.docx" }
For Each uncPath As String In uncPaths
Console.WriteLine("Input string: " + uncPath)
Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
' Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
' Returned string: C:\ThingsToDo.txt
'
' Input string: \\MyMachine\c$\ThingsToDo.txt
' Returned string: c:\ThingsToDo.txt
'
' Input string: \\MyMachine\d$\documents\mydocument.docx
' Returned string: d:\documents\mydocument.docx
Il criterio di espressione regolare è definito dall'espressione seguente:
"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"
Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.
Modello | Descrizione |
---|---|
\\\\ |
Trova la corrispondenza con due caratteri barra rovesciata consecutiva (\ ). Poiché il carattere barra rovesciata viene interpretato come carattere di escape, ogni barra rovesciata deve essere preceduta da un'altra barra rovesciata. |
+ Environment.MachineName + |
Trova la corrispondenza con la stringa restituita dalla Environment.MachineName proprietà . |
(?:\.\w+)* |
Trova la corrispondenza con il carattere punto (. ) seguito da uno o più caratteri di parola. Questa corrispondenza può verificarsi zero o più volte. La sottoespressione corrispondente non viene acquisita. |
\\ |
Trova la corrispondenza con una barra rovesciata (\ ). |
([" + driveNames + "]) |
Trova la corrispondenza con la classe di caratteri costituita dalle singole lettere di unità. Questa corrispondenza è la prima sottoespressione acquisita. |
\$ |
Trova la corrispondenza con il carattere del simbolo del dollaro letterale ($ ). |
Il modello $1
di sostituzione sostituisce l'intera corrispondenza con la prima sottoespressione acquisita. Ciò significa che sostituisce il computer UNC e il nome dell'unità con la lettera di unità.
Commenti
I metodi statici Replace
sono equivalenti alla costruzione di un Regex oggetto con il modello di espressione regolare specificato e la chiamata al metodo Replace
di istanza .
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido. Se si specifica RightToLeft per il options
parametro , la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.
Il replacement
parametro specifica la stringa che deve sostituire ogni corrispondenza in input
. replacement
può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il criterio a*${test}b
di sostituzione inserisce la stringa "a*" seguita dalla sottostringa corrispondente al test
gruppo di acquisizione, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.
Nota
Le sostituzioni sono gli unici elementi del linguaggio delle espressioni regolari riconosciuti in un criterio di sostituzione. Tutti gli altri elementi del linguaggio delle espressioni regolari, inclusi i caratteri di escape, sono consentiti solo nei modelli di espressione regolare e non vengono riconosciuti nei modelli di sostituzione.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato per il dominio dell'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.
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
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 utilizzato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per la sostituzione di una corrispondenza del criterio è Replace(String, String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.
Vedi anche
- RegexOptions
- Sostituzioni nelle espressioni regolari
- Elementi del linguaggio di espressioni regolari
Si applica a
Replace(String, MatchEvaluator)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator.
public:
System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string
Public Function Replace (input As String, evaluator As MatchEvaluator) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- evaluator
- MatchEvaluator
Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.
Restituisce
Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
input
o evaluator
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio di codice seguente viene visualizzata una stringa originale, che corrisponde a ogni parola nella stringa originale, converte il primo carattere di ogni corrispondenza in lettere maiuscole e quindi visualizza la stringa convertita.
using System;
using System.Text.RegularExpressions;
class RegExSample
{
static string CapText(Match m)
{
// Get the matched string.
string x = m.ToString();
// If the first char is lower case...
if (char.IsLower(x[0]))
{
// Capitalize it.
return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
}
return x;
}
static void Main()
{
string text = "four score and seven years ago";
Console.WriteLine($"text=[{text}]");
Regex rx = new Regex(@"\w+");
string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));
Console.WriteLine($"result=[{result}]");
}
}
// The example displays the following output:
// text=[four score and seven years ago]
// result=[Four Score And Seven Years Ago]
Imports System.Text.RegularExpressions
Module RegExSample
Function CapText(ByVal m As Match) As String
' Get the matched string.
Dim x As String = m.ToString()
' If the first char is lower case...
If Char.IsLower(x.Chars(0)) Then
' Capitalize it.
Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
End If
Return x
End Function
Sub Main()
Dim text As String = "four score and seven years ago"
Console.WriteLine($"text=[{text}]")
Dim rx As New Regex("\w+")
Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)
Console.WriteLine($"result=[{result}]")
End Sub
End Module
' The example displays the following output:
' text=[four score and seven years ago]
' result=[Four Score And Seven Years Ago]
Commenti
Il Regex.Replace(String, MatchEvaluator) metodo è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:
La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione dell'espressione regolare.
La stringa di sostituzione deriva da un'elaborazione eseguita sulla stringa corrispondente.
La stringa di sostituzione deriva dall'elaborazione condizionale.
Il metodo equivale a chiamare il Regex.Matches(String) metodo e a passare ogni Match oggetto nella raccolta restituita MatchCollection al evaluator
delegato.
L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .
Il evaluator
parametro è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Per trovare la corrispondenza con il MatchEvaluator delegato, il metodo personalizzato deve avere la firma seguente.
public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String
Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. 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 Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
Vedi anche
- MatchEvaluator
- Sostituzioni nelle espressioni regolari
- Linguaggio di espressioni regolari - Riferimento rapido
Si applica a
Replace(String, MatchEvaluator, Int32)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa restituita da un delegato MatchEvaluator.
public:
System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string
Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- evaluator
- MatchEvaluator
Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.
- count
- Int32
Numero massimo di volte in cui la sostituzione avrà luogo.
Restituisce
Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
input
o evaluator
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene utilizzata un'espressione regolare per eseguire deliberatamente l'errore di metà delle parole in un elenco. Usa l'espressione \w*(ie|ei)\w*
regolare per trovare le parole che includono i caratteri "ie" o "ei". Passa la prima metà delle parole corrispondenti al ReverseLetter
metodo , che a sua volta usa il Replace(String, String, String, RegexOptions) metodo per invertire "i" e "e" nella stringa corrispondente. Le parole rimanenti rimangono invariate.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "deceive relieve achieve belief fierce receive";
string pattern = @"\w*(ie|ei)\w*";
Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
Console.WriteLine("Original string: " + input);
string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter),
input.Split(' ').Length / 2);
Console.WriteLine("Returned string: " + result);
}
static string ReverseLetter(Match match)
{
return Regex.Replace(match.Value, "([ie])([ie])", "$2$1",
RegexOptions.IgnoreCase);
}
}
// The example displays the following output:
// Original string: deceive relieve achieve belief fierce receive
// Returned string: decieve releive acheive belief fierce receive
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "deceive relieve achieve belief fierce receive"
Dim pattern As String = "\w*(ie|ei)\w*"
Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
Console.WriteLine("Original string: " + input)
Dim result As String = rgx.Replace(input, AddressOf ReverseLetter,
input.Split(" "c).Length \ 2)
Console.WriteLine("Returned string: " + result)
End Sub
Public Function ReverseLetter(match As Match) As String
Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1",
RegexOptions.IgnoreCase)
End Function
End Module
' The example displays the following output:
' Original string: deceive relieve achieve belief fierce receive
' Returned string: decieve releive acheive belief fierce receive
L'espressione regolare \w*(ie|ei)\w*
viene definita come illustrato nella tabella seguente.
Modello | Descrizione |
---|---|
\w* |
Trova la corrispondenza di zero o più caratteri alfanumerici. |
(ie|ei) |
Trova la corrispondenza con "ie" o "ei". |
\w* |
Trova la corrispondenza di zero o più caratteri alfanumerici. |
Il modello ([ie])([ie])
di espressione regolare nel ReverseLetter
metodo corrisponde al primo "i" o "e" nel diphthong "ie" o "ei" e assegna la lettera al primo gruppo di acquisizione. Corrisponde al secondo "i" o "e" e assegna la lettera al secondo gruppo di acquisizione. I due caratteri vengono quindi invertiti chiamando il Replace(String, String, String) metodo con il modello di $2$1
sostituzione .
Commenti
Il Regex.Replace(String, MatchEvaluator, Int32) metodo è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:
La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione dell'espressione regolare.
La stringa di sostituzione deriva da un'elaborazione eseguita sulla stringa corrispondente.
La stringa di sostituzione deriva dall'elaborazione condizionale.
Il metodo equivale a chiamare il Regex.Matches(String) metodo e a passare i primiMatchcount
oggetti nella raccolta restituita MatchCollection al evaluator
delegato.
L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .
Il evaluator
parametro è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Per trovare la corrispondenza con il MatchEvaluator delegato, il metodo personalizzato deve avere la firma seguente.
public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String
Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. 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 Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato sostituzioni alla stringa di input.
Vedi anche
- MatchEvaluator
- Sostituzioni nelle espressioni regolari
- Linguaggio di espressioni regolari - Riferimento rapido
Si applica a
Replace(String, String, MatchEvaluator)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa restituita da un delegato MatchEvaluator.
public:
static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- evaluator
- MatchEvaluator
Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.
Restituisce
Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione. Se pattern
non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
, pattern
o evaluator
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre le singole parole da una stringa e quindi viene utilizzato un delegato per chiamare un MatchEvaluator metodo denominato WordScramble
che esegue lo scramble delle singole lettere nella parola. A tale scopo, il WordScramble
metodo crea una matrice contenente i caratteri nella corrispondenza. Crea anche una matrice parallela che popola con numeri a virgola mobile casuali. Le matrici vengono ordinate chiamando il Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metodo e la matrice ordinata viene fornita come argomento a un String costruttore di classe. Questa stringa appena creata viene quindi restituita dal WordScramble
metodo . Il criterio \w+
di espressione regolare corrisponde a uno o più caratteri di parola. Il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza finché non rileva un carattere non di parola, ad esempio uno spazio vuoto.
using System;
using System.Collections;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string words = "letter alphabetical missing lack release " +
"penchant slack acryllic laundry cease";
string pattern = @"\w+";
MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
Console.WriteLine("Original words:");
Console.WriteLine(words);
Console.WriteLine();
Console.WriteLine("Scrambled words:");
Console.WriteLine(Regex.Replace(words, pattern, evaluator));
}
public static string WordScrambler(Match match)
{
int arraySize = match.Value.Length;
// Define two arrays equal to the number of letters in the match.
double[] keys = new double[arraySize];
char[] letters = new char[arraySize];
// Instantiate random number generator'
Random rnd = new Random();
for (int ctr = 0; ctr < match.Value.Length; ctr++)
{
// Populate the array of keys with random numbers.
keys[ctr] = rnd.NextDouble();
// Assign letter to array of letters.
letters[ctr] = match.Value[ctr];
}
Array.Sort(keys, letters, 0, arraySize, Comparer.Default);
return new String(letters);
}
}
// The example displays output similar to the following:
// Original words:
// letter alphabetical missing lack release penchant slack acryllic laundry cease
//
// Scrambled words:
// elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase
Imports System.Collections
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim words As String = "letter alphabetical missing lack release " + _
"penchant slack acryllic laundry cease"
Dim pattern As String = "\w+"
Dim evaluator As MatchEvaluator = AddressOf WordScrambler
Console.WriteLine("Original words:")
Console.WriteLine(words)
Console.WriteLine("Scrambled words:")
Console.WriteLine(Regex.Replace(words, pattern, evaluator))
End Sub
Public Function WordScrambler(match As Match) As String
Dim arraySize As Integer = match.Value.Length - 1
' Define two arrays equal to the number of letters in the match.
Dim keys(arraySize) As Double
Dim letters(arraySize) As Char
' Instantiate random number generator'
Dim rnd As New Random()
For ctr As Integer = 0 To match.Value.Length - 1
' Populate the array of keys with random numbers.
keys(ctr) = rnd.NextDouble()
' Assign letter to array of letters.
letters(ctr) = match.Value.Chars(ctr)
Next
Array.Sort(keys, letters, 0, arraySize, Comparer.Default)
Return New String(letters)
End Function
End Module
' The example displays output similar to the following:
' Original words:
' letter alphabetical missing lack release penchant slack acryllic laundry cease
'
' Scrambled words:
' elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase
Commenti
Il Regex.Replace(String, String, MatchEvaluator) metodo è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:
La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione dell'espressione regolare.
La stringa di sostituzione deriva da un'elaborazione eseguita sulla stringa corrispondente.
La stringa di sostituzione deriva dall'elaborazione condizionale.
Il metodo equivale a chiamare il Regex.Matches(String, String) metodo e a passare ogni Match oggetto nella raccolta restituita MatchCollection al evaluator
delegato.
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.
Il evaluator
parametro è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Per trovare la corrispondenza con il MatchEvaluator delegato, il metodo personalizzato deve avere la firma seguente.
public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String
Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato per il dominio dell'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.
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato eventuali sostituzioni alla stringa di input.
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 utilizzato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per la valutazione e la sostituzione di una corrispondenza dei criteri è Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.
Vedi anche
- MatchEvaluator
- Sostituzioni nelle espressioni regolari
- Elementi del linguaggio di espressioni regolari
Si applica a
Replace(String, String, Int32)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
public:
System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);
public string Replace (string input, string replacement, int count);
member this.Replace : string * string * int -> string
Public Function Replace (input As String, replacement As String, count As Integer) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- replacement
- String
Stringa di sostituzione.
- count
- Int32
Numero massimo di volte in cui la sostituzione può aver luogo.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
input
o replacement
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente vengono sostituite le prime cinque occorrenze di caratteri duplicati con un singolo carattere. Il modello (\w)\1
di espressione regolare corrisponde a occorrenze consecutive di un singolo carattere e assegna la prima occorrenza al primo gruppo di acquisizione. Il modello $1
di sostituzione sostituisce l'intera corrispondenza con il primo gruppo acquisito.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string str = "aabccdeefgghiijkklmm";
string pattern = "(\\w)\\1";
string replacement = "$1";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(str, replacement, 5);
Console.WriteLine("Original String: '{0}'", str);
Console.WriteLine("Replacement String: '{0}'", result);
}
}
// The example displays the following output:
// Original String: 'aabccdeefgghiijkklmm'
// Replacement String: 'abcdefghijkklmm'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim str As String = "aabccdeefgghiijkklmm"
Dim pattern As String = "(\w)\1"
Dim replacement As String = "$1"
Dim rgx As New Regex(pattern)
Dim result As String = rgx.Replace(str, replacement, 5)
Console.WriteLine("Original String: '{0}'", str)
Console.WriteLine("Replacement String: '{0}'", result)
End Sub
End Module
' The example displays the following output:
' Original String: 'aabccdeefgghiijkklmm'
' Replacement String: 'abcdefghijkklmm'
Commenti
La ricerca delle corrispondenze inizia all'inizio input
della stringa. L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex . Se count
è negativo, le sostituzioni continuano alla fine della stringa. Se count
supera il numero di corrispondenze, tutte le corrispondenze vengono sostituite.
Il replacement
parametro specifica la stringa che consiste nel sostituire le prime count
corrispondenze in input
. replacement
può essere costituita da qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il modello a*${test}b
di sostituzione inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione, se presente, seguita dalla test
stringa "b". Il carattere * non viene riconosciuto come metacharacter all'interno di un modello di sostituzione.
Nota
Le sostituzioni sono gli unici elementi del linguaggio delle espressioni regolari riconosciuti in un modello di sostituzione. Tutti gli altri elementi del linguaggio delle espressioni regolari, inclusi i escape dei caratteri, sono consentiti solo nei modelli di espressione regolari e non sono riconosciuti nei modelli di sostituzione.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata l'eccezione se l'operazione supera qualsiasi valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato eventuali sostituzioni alla stringa di input.
Vedi anche
Si applica a
Replace(String, String)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
public:
System::String ^ Replace(System::String ^ input, System::String ^ replacement);
public string Replace (string input, string replacement);
member this.Replace : string * string -> string
Public Function Replace (input As String, replacement As String) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- replacement
- String
Stringa di sostituzione.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
input
o replacement
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente viene definita un'espressione regolare, che \s+
corrisponde a uno o più caratteri di spazio vuoto. La stringa di sostituzione , " ", li sostituisce con un singolo carattere di spazio.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is text with far too much " +
"white space.";
string pattern = "\\s+";
string replacement = " ";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(input, replacement);
Console.WriteLine("Original String: {0}", input);
Console.WriteLine("Replacement String: {0}", result);
}
}
// The example displays the following output:
// Original String: This is text with far too much white space.
// Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is text with far too much " + _
"white space."
Dim pattern As String = "\s+"
Dim replacement As String = " "
Dim rgx As New Regex(pattern)
Dim result As String = rgx.Replace(input, replacement)
Console.WriteLine("Original String: {0}", input)
Console.WriteLine("Replacement String: {0}", result)
End Sub
End Module
' The example displays the following output:
' Original String: This is text with far too much white space.
' Replacement String: This is text with far too much white space.
Nell'esempio seguente viene definita un'espressione regolare, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?
, e un modello di sostituzione, $2
che rimuove un simbolo di valuta iniziale o finale da un valore numerico.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
string input = "$17.43 €2 16.33 £0.98 0.43 £43 12€ 17";
string replacement = "$2";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(input, replacement);
Console.WriteLine("Original String: '{0}'", input);
Console.WriteLine("Replacement String: '{0}'", result);
}
}
// The example displays the following output:
// Original String: '$17.43 €2 16.33 £0.98 0.43 £43 12€ 17'
// Replacement String: '17.43 2 16.33 0.98 0.43 43 12 17'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
Dim input As String = "$17.43 €2 16.33 £0.98 0.43 £43 12€ 17"
Dim replacement As String = "$2"
Dim rgx As New Regex(pattern)
Dim result As String = rgx.Replace(input, replacement)
Console.WriteLine("Original String: '{0}'", input)
Console.WriteLine("Replacement String: '{0}'", result)
End Sub
End Module
' The example displays the following output:
' Original String: '$17.43 €2 16.33 £0.98 0.43 £43 12€ 17'
' Replacement String: '17.43 2 16.33 0.98 0.43 43 12 17'
L'espressione regolare viene interpretata come illustrato nella tabella seguente.
Modello | Descrizione |
---|---|
\p{Sc} |
Corrisponde a un simbolo di valuta. {Sc} indica qualsiasi carattere membro della categoria Simbolo Unicode, Valuta. |
\s? |
Trova la corrispondenza di uno o nessuno spazio vuoto. |
(\p{Sc}\s?)? |
Corrisponde a zero o una occorrenza della combinazione di un simbolo di valuta seguita da zero o da uno spazio vuoto. Equivale al primo gruppo di acquisizione. |
\d+ |
Trova la corrispondenza con una o più cifre decimali. |
\.? |
Corrisponde a zero o una occorrenza di un punto (usato come carattere separatore decimale). |
((?<=\.)\d+)? |
Se un punto è il carattere precedente, corrisponde a una o più cifre decimali. Questo modello può essere corrispondente a zero o una volta. |
(\d+\.?((?<=\.)\d+)?) |
Corrisponde al modello di una o più cifre decimali seguite da un periodo facoltativo e da cifre decimali aggiuntive. Equivale al secondo gruppo di acquisizione. La chiamata al Replace(String, String) metodo sostituisce l'intera corrispondenza con il valore di questo gruppo acquisito. |
(?(1)|\s?\p{Sc})? |
Se il primo gruppo acquisito esiste, corrisponde a una stringa vuota. In caso contrario, corrisponde a zero o uno spazio vuoto seguito da un simbolo di valuta. |
Commenti
La ricerca delle corrispondenze inizia all'inizio input
della stringa. L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .
Il replacement
parametro specifica la stringa che consiste nel sostituire ogni corrispondenza in input
. replacement
può essere costituita da qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il modello a*${test}b
di sostituzione inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione, se presente, seguita dalla test
stringa "b". Il carattere * non viene riconosciuto come metacharacter all'interno di un modello di sostituzione.
Nota
Le sostituzioni sono gli unici elementi del linguaggio delle espressioni regolari riconosciuti in un modello di sostituzione. Tutti gli altri elementi del linguaggio delle espressioni regolari, inclusi i escape dei caratteri, sono consentiti solo nei modelli di espressione regolari e non sono riconosciuti nei modelli di sostituzione.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata l'eccezione se l'operazione supera qualsiasi valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato eventuali sostituzioni alla stringa di input.
Vedi anche
Si applica a
Replace(String, String, Int32, Int32)
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
- Source:
- Regex.Replace.cs
In una sottostringa di input specificata, sostituisce un numero massimo di stringhe specificato corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.
public:
System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);
public string Replace (string input, string replacement, int count, int startat);
member this.Replace : string * string * int * int -> string
Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String
Parametri
- input
- String
Stringa nella quale cercare una corrispondenza.
- replacement
- String
Stringa di sostituzione.
- count
- Int32
Numero massimo di volte in cui la sostituzione può aver luogo.
- startat
- Int32
Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.
Restituisce
Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.
Eccezioni
input
o replacement
è null
.
startat
è minore di zero o maggiore della lunghezza di input
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Esempio
Nell'esempio seguente vengono vuoti doppio, ma la prima riga di una stringa. Definisce un modello di espressione regolare, , ^.*$
che corrisponde a una riga di testo, chiama il Match(String) metodo per corrispondere alla prima riga della stringa e usa le Match.Index
proprietà e Match.Count
per determinare la posizione iniziale della seconda riga.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "Instantiating a New Type\n" +
"Generally, there are two ways that an\n" +
"instance of a class or structure can\n" +
"be instantiated. ";
string pattern = "^.*$";
string replacement = "\n$&";
Regex rgx = new Regex(pattern, RegexOptions.Multiline);
string result = String.Empty;
Match match = rgx.Match(input);
// Double space all but the first line.
if (match.Success)
result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);
Console.WriteLine(result);
}
}
// The example displays the following output:
// Instantiating a New Type
//
// Generally, there are two ways that an
//
// instance of a class or structure can
//
// be instntiated.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Instantiating a New Type" + vbCrLf + _
"Generally, there are two ways that an" + vbCrLf + _
"instance of a class or structure can" + vbCrLf + _
"be instantiated. "
Dim pattern As String = "^.*$"
Dim replacement As String = vbCrLf + "$&"
Dim rgx As New Regex(pattern, RegexOptions.Multiline)
Dim result As String = String.Empty
Dim match As Match = rgx.Match(input)
' Double space all but the first line.
If match.Success Then
result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
End If
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' Instantiating a New Type
'
' Generally, there are two ways that an
'
' instance of a class or structure can
'
' be instntiated.
Il criterio di ricerca di espressioni regolari ^.*$
è definito nel modo illustrato nella tabella seguente.
Modello | Descrizione |
---|---|
^ |
Corrisponde all'inizio di una riga. Si noti che l'oggetto è stato creato tramite l'opzione Regex . In caso contrario, questa classe di caratteri corrisponde solo all'inizio RegexOptions.Multiline della stringa di input. |
.* |
Corrisponde a qualsiasi carattere zero o più volte. |
$ |
Corrisponde alla fine di una riga. Si noti che l'oggetto è stato creato tramite l'opzione Regex . In caso contrario, questa classe di caratteri corrisponde solo all'inizio RegexOptions.Multiline della stringa di input. |
La stringa di sostituzione (vbCrLf + "$&"
in Visual Basic, "\n$&"
in C#) aggiunge una nuova riga prima della stringa corrispondente. Si noti che \n
nell'esempio C# viene interpretato come carattere di nuova riga dal compilatore C#. Non rappresenta un escape di carattere di espressione regolare.
Commenti
La ricerca delle corrispondenze inizia nella stringa nella input
posizione specificata dal startat
parametro . L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex . Se count
è negativo, le sostituzioni continuano alla fine della stringa. Se count
supera il numero di corrispondenze, tutte le corrispondenze vengono sostituite.
Per altre informazioni su startat
, vedere la sezione Osservazioni di Match(String, Int32).
Il replacement
parametro specifica la stringa che consiste nel sostituire ogni corrispondenza in input
. replacement
può essere costituita da qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il modello a*${test}b
di sostituzione inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione, se presente, seguita dalla test
stringa "b". Il carattere * non viene riconosciuto come metacharacter all'interno di un modello di sostituzione.
Nota
Le sostituzioni sono gli unici elementi del linguaggio delle espressioni regolari riconosciuti in un modello di sostituzione. Tutti gli altri elementi del linguaggio delle espressioni regolari, inclusi i escape dei caratteri, sono consentiti solo nei modelli di espressione regolari e non sono riconosciuti nei modelli di sostituzione.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di sostituzione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata l'eccezione se l'operazione supera qualsiasi valore di timeout stabilito per il dominio dell'applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Poiché il metodo restituisce input
invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha apportato eventuali sostituzioni alla stringa di input.
Vedi anche
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per