Regex.Replace Metodo

Definizione

In una stringa di input specificata, sostituisce le stringhe corrispondenti a un criterio di espressione regolare con una stringa di sostituzione specificata.In a specified input string, replaces strings that match a regular expression pattern with a specified replacement string.

Overload

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.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Le opzioni specificate modificano l'operazione di corrispondenza.Specified options modify the matching operation.

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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Le opzioni specificate modificano l'operazione di corrispondenza.Specified options modify the matching operation.

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

pattern
String

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

evaluator
MatchEvaluator

Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions

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

matchTimeout
TimeSpan

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

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

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

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

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

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

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

Esempi

Nell'esempio seguente viene usata un'espressione regolare per estrarre le singole parole da una stringa, quindi viene usato MatchEvaluator un delegato per chiamare un metodo WordScramble denominato che consente di comprimere le singole lettere della parola.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. A tale scopo, il WordScramble metodo crea una matrice contenente i caratteri della corrispondenza.To do this, the WordScramble method creates an array that contains the characters in the match. Viene inoltre creata una matrice parallela che popola con numeri a virgola mobile casuali.It also creates a parallel array that it populates with random floating-point numbers. 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.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. Questa stringa appena creata viene quindi restituita dal WordScramble metodo.This newly created string is then returned by the WordScramble method. Il criterio \w+ di ricerca di espressioni regolari corrisponde a uno o più caratteri alfanumerici. il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza fino a quando non viene rilevato un carattere non alfanumerico, ad esempio un carattere di spazio vuoto.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. La chiamata al Replace(String, String, MatchEvaluator, RegexOptions) metodo include l' RegexOptions.IgnorePatternWhitespace opzione in modo che il commento nel criterio \w+ # Matches all the characters in a word. di ricerca di espressioni regolari venga ignorato dal motore delle espressioni regolari.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

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 espressione regolare se si verifica una delle condizioni seguenti:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Se la stringa di sostituzione non può essere specificata immediatamente da un criterio di sostituzione di un'espressione regolare.If the replacement string cannot readily be specified by a regular expression replacement pattern.

  • Se la stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.If the replacement string results from some processing performed on the matched string.

  • Se la stringa di sostituzione risulta dall'elaborazione condizionale.If the replacement string results from conditional processing.

Il metodo equivale Regex.Matches(String, String, RegexOptions) a chiamare il metodo e a passare ogni Match oggetto della raccolta restituita MatchCollection al evaluator delegato.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

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

Il evaluator parametro è il delegato per un metodo personalizzato definito dall'utente e che esamina ogni corrispondenza.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Il metodo personalizzato deve avere la firma seguente per trovare la MatchEvaluator corrispondenza con il delegato.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.Your custom method returns a string that replaces the matched input.

Se si specifica RightToLeft per il options parametro, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta verso sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e viene spostata a destra.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Note per i chiamanti

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

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

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

Vedi anche

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

pattern
String

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

replacement
String

Stringa di sostituzione.The replacement string.

options
RegexOptions

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

matchTimeout
TimeSpan

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

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

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

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

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

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

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

Esempi

Nell'esempio seguente viene usato Replace(String, String, String, RegexOptions, TimeSpan) il metodo per sostituire il computer locale e i nomi di unità in un percorso UNC con un percorso di file locale.The following example uses the Replace(String, String, String, RegexOptions, TimeSpan) method to replace the local machine and drive names in a UNC path with a local file path. 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.The regular expression uses the Environment.MachineName property to include the name of the local computer and the Environment.GetLogicalDrives method to include the names of the logical drives. Tutti i confronti di stringhe di espressioni regolari non fanno distinzione tra maiuscole e minuscole e ogni singola operazione di sostituzione scade se non è possibile trovare una corrispondenza in 0,5 secondo.All regular expression string comparisons are case-insensitive, and any single replacement operation times out if a match cannot be found in 0.5 second. Per eseguire correttamente l'esempio, è necessario sostituire la stringa letterale "computer" con il nome del computer locale.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

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 ricerca di espressioni regolari è definito dall'espressione seguente:The regular expression pattern is defined by the following expression:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.The following table shows how the regular expression pattern is interpreted.

ModelloPattern DescriptionDescription
\\\\ Corrisponde a due caratteri di\barra rovesciata () consecutivi.\\\\ Match two consecutive backslash (\) characters. Poiché il carattere barra rovesciata viene interpretato come carattere di escape, è necessario che ogni barra rovesciata venga preceduta da un'altra barra rovesciata.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Trova la corrispondenza con la stringa restituita Environment.MachineName dalla proprietà.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Corrisponde al carattere punto.() seguito da uno o più caratteri alfanumerici.Match the period (.) character followed by one or more word characters. Questa corrispondenza può verificarsi zero o più volte.This match can occur zero or more times. La sottoespressione corrispondente non viene acquisita.The matched subexpression is not captured.
\\ Corrisponde a un carattere\barra rovesciata ().\\ Match a backslash (\) character.
([" + driveNames + "]) Corrisponde alla classe di caratteri costituita dalle singole lettere di unità.Match the character class that consists of the individual drive letters. Corrisponde alla prima sottoespressione acquisita.This match is the first captured subexpression.
\$ Corrisponde al carattere di segno di$Dollaro ().Match the literal dollar sign ($) character.

Il criterio $1 di sostituzione sostituisce l'intera corrispondenza con la prima sottoespressione acquisita.The replacement pattern $1 replaces the entire match with the first captured subexpression. Ovvero sostituisce il computer UNC e il nome dell'unità con la lettera di unità.That is, it replaces the UNC machine and drive name with the drive letter.

Commenti

I metodi Replace statici sono equivalenti alla costruzione di Regex un oggetto con il modello di espressione regolare specificato e alla chiamata Replacedel metodo di istanza.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Se si specifica RightToLeft per il options parametro, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta verso sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e viene spostata a destra.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Il replacement parametro specifica la stringa che sostituisce ogni corrispondenza in input.The replacement parameter specifies the string that is to replace each match in input. replacementpuò essere costituito da qualsiasi combinazione di testo letterale e sostituzioni.replacement can consist of any combination of literal text and substitutions. Ad esempio, il criterio a*${test}b di sostituzione inserisce la stringa "a *" seguita dalla sottostringa corrispondente al gruppo test di acquisizione, se presente, seguita dalla stringa "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Il carattere * non è riconosciuto come metacarattere in un criterio di sostituzione.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Le sostituzioni sono gli unici elementi del linguaggio di espressioni regolari riconosciuti in un criterio di sostituzione.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Note per i chiamanti

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

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

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

Vedi anche

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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

evaluator
MatchEvaluator

Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32

Numero massimo di volte in cui la sostituzione avrà luogo.The maximum number of times the replacement will occur.

startat
Int32

Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.The character position in the input string where the search begins.

Restituisce

Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

input o evaluator è null.input or evaluator is null.

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

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

Commenti

Il Regex.Replace(String, MatchEvaluator, Int32, Int32) metodo è utile per sostituire una corrispondenza di espressione regolare se si verifica una delle condizioni seguenti:The Regex.Replace(String, MatchEvaluator, Int32, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di un'espressione regolare.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.The replacement string results from some processing done on the matched string.

  • Stringa di sostituzione risultante dall'elaborazione condizionale.The replacement string results from conditional processing.

Il metodo Regex.Matches(String, Int32) equivale a chiamare il metodo e a passare i primi count Match oggetti della raccolta restituita MatchCollection al evaluator delegato.The method is equivalent to calling the Regex.Matches(String, Int32) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .The regular expression is the pattern defined by the constructor for the current Regex object.

Il evaluator parametro è il delegato per un metodo personalizzato definito dall'utente e che esamina ogni corrispondenza.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Il metodo personalizzato deve avere la firma seguente per trovare la MatchEvaluator corrispondenza con il delegato.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.Your custom method returns a string that replaces the matched input.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Le opzioni specificate modificano l'operazione di corrispondenza.Specified options modify the matching operation.

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

pattern
String

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

evaluator
MatchEvaluator

Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions

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

Restituisce

Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

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

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

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

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

Esempi

Nell'esempio seguente viene usata un'espressione regolare per estrarre le singole parole da una stringa, quindi viene usato MatchEvaluator un delegato per chiamare un metodo WordScramble denominato che consente di comprimere le singole lettere della parola.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. A tale scopo, il WordScramble metodo crea una matrice contenente i caratteri della corrispondenza.To do this, the WordScramble method creates an array that contains the characters in the match. Viene inoltre creata una matrice parallela che popola con numeri a virgola mobile casuali.It also creates a parallel array that it populates with random floating-point numbers. 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.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. Questa stringa appena creata viene quindi restituita dal WordScramble metodo.This newly created string is then returned by the WordScramble method. Il criterio \w+ di ricerca di espressioni regolari corrisponde a uno o più caratteri alfanumerici. il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza fino a quando non viene rilevato un carattere non alfanumerico, ad esempio un carattere di spazio vuoto.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. La chiamata al Replace(String, String, MatchEvaluator, RegexOptions) metodo include l' RegexOptions.IgnorePatternWhitespace opzione in modo che il commento nel criterio \w+ # Matches all the characters in a word. di ricerca di espressioni regolari venga ignorato dal motore delle espressioni regolari.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

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 espressione regolare in se si verifica una delle condizioni seguenti:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match in if any of the following conditions is true:

  • La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di un'espressione regolare.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.The replacement string results from some processing done on the matched string.

  • Stringa di sostituzione risultante dall'elaborazione condizionale.The replacement string results from conditional processing.

Il metodo equivale Regex.Matches(String, String, RegexOptions) a chiamare il metodo e a passare ogni Match oggetto della raccolta restituita MatchCollection al evaluator delegato.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

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

Il evaluator parametro è il delegato per un metodo personalizzato definito dall'utente e che esamina ogni corrispondenza.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Il metodo personalizzato deve avere la firma seguente per trovare la MatchEvaluator corrispondenza con il delegato.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.Your custom method returns a string that replaces the matched input.

Se si specifica RightToLeft per il options parametro, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta verso sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e viene spostata a destra.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

L' RegexMatchTimeoutException eccezione 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.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

replacement
String

Stringa di sostituzione.The replacement string.

count
Int32

Numero massimo di volte in cui la sostituzione può aver luogo.Maximum number of times the replacement can occur.

startat
Int32

Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.The character position in the input string where the search begins.

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

input o replacement è null.input or replacement is null.

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

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

Esempi

Nell'esempio seguente vengono raddoppiati gli spazi, tranne la prima riga di una stringa.The following example double-spaces all but the first line of a string. Definisce un modello di espressione regolare, ^.*$, che corrisponde a una riga di testo, chiama Match(String) il metodo per trovare la corrispondenza con la prima riga della stringa e Match.Index USA Match.Count le proprietà e per determinare la posizione iniziale del secondo linea.It defines a regular expression pattern, ^.*$, that matches a line of text, calls the Match(String) method to match the first line of the string, and uses the Match.Index and Match.Count properties to determine the starting position of the second line.

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.The regular expression pattern ^.*$ is defined as shown in the following table.

ModelloPattern DescriptionDescription
^ Corrisponde all'inizio di una riga.Match the start of a line. Si noti che è Regex stata creata un'istanza dell'oggetto utilizzando RegexOptions.Multiline l'opzione. in caso contrario, la classe di caratteri corrisponderebbe solo all'inizio della stringa di input.(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)
.* Corrisponde a qualsiasi carattere zero o più volte.Match any character zero or more times.
$ Corrisponde alla fine di una riga.Match the end of a line. Si noti che è Regex stata creata un'istanza dell'oggetto utilizzando RegexOptions.Multiline l'opzione. in caso contrario, la classe di caratteri corrisponderebbe solo all'inizio della stringa di input.(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)

La stringa di sostituzionevbCrLf + "$&" (in Visual Basic "\n$&" , C#in) aggiunge una nuova riga prima della stringa corrispondente.The replacement string (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) adds a new line before the matched string. Si noti \n che nell' C# esempio viene interpretato come carattere di nuova riga dal C# compilatore e non rappresenta l'escape di caratteri di un'espressione regolare.Note that \n in the C# example is interpreted as the newline character by the C# compiler; it does not represent a regular expression character escape.

Commenti

La ricerca di corrispondenze inizia nella input stringa in corrispondenza della posizione specificata startat dal parametro.The search for matches starts in the input string at the position specified by the startat parameter. L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .The regular expression is the pattern defined by the constructor for the current Regex object. Se count è negativo, le sostituzioni continuano fino alla fine della stringa.If count is negative, replacements continue to the end of the string. Se count supera il numero di corrispondenze, verranno sostituite tutte le corrispondenze.If count exceeds the number of matches, all matches are replaced.

Il replacement parametro specifica la stringa che sostituisce ogni corrispondenza in input.The replacement parameter specifies the string that is to replace each match in input. replacementpuò essere costituito da qualsiasi combinazione di testo letterale e sostituzioni.replacement can consist of any combination of literal text and substitutions. Ad esempio, il criterio a*${test}b di sostituzione inserisce la stringa "a *" seguita dalla sottostringa corrispondente al gruppo test di acquisizione, se presente, seguita dalla stringa "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Il carattere * non è riconosciuto come metacarattere in un criterio di sostituzione.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Le sostituzioni sono gli unici elementi del linguaggio di espressioni regolari riconosciuti in un criterio di sostituzione.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Le opzioni specificate modificano l'operazione di corrispondenza.Specified options modify the matching operation.

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

pattern
String

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

replacement
String

Stringa di sostituzione.The replacement string.

options
RegexOptions

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

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

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

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

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

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

Esempi

Nell'esempio seguente viene usato Replace(String, String, String, RegexOptions) il metodo per sostituire il computer locale e i nomi di unità in un percorso UNC con un percorso di file locale.The following example uses the Replace(String, String, String, RegexOptions) method to replace the local machine and drive names in a UNC path with a local file path. 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.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. Tutti i confronti di stringhe di espressioni regolari non fanno distinzione tra maiuscole e minuscoleAll regular expression string comparisons are case-insensitive. Per eseguire correttamente l'esempio, è necessario sostituire la stringa letterale "computer" con il nome del computer locale.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

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 ricerca di espressioni regolari è definito dall'espressione seguente:The regular expression pattern is defined by the following expression:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.The following table shows how the regular expression pattern is interpreted.

ModelloPattern DescriptionDescription
\\\\ Corrisponde a due caratteri di\barra rovesciata () consecutivi.\\\\ Match two consecutive backslash (\) characters. Poiché il carattere barra rovesciata viene interpretato come carattere di escape, è necessario che ogni barra rovesciata venga preceduta da un'altra barra rovesciata.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Trova la corrispondenza con la stringa restituita Environment.MachineName dalla proprietà.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Corrisponde al carattere punto.() seguito da uno o più caratteri alfanumerici.Match the period (.) character followed by one or more word characters. Questa corrispondenza può verificarsi zero o più volte.This match can occur zero or more times. La sottoespressione corrispondente non viene acquisita.The matched subexpression is not captured.
\\ Corrisponde a un carattere\barra rovesciata ().\\ Match a backslash (\) character.
([" + driveNames + "]) Corrisponde alla classe di caratteri costituita dalle singole lettere di unità.Match the character class that consists of the individual drive letters. Corrisponde alla prima sottoespressione acquisita.This match is the first captured subexpression.
\$ Corrisponde al carattere di segno di$Dollaro ().Match the literal dollar sign ($) character.

Il criterio $1 di sostituzione sostituisce l'intera corrispondenza con la prima sottoespressione acquisita.The replacement pattern $1 replaces the entire match with the first captured subexpression. Ovvero sostituisce il computer UNC e il nome dell'unità con la lettera di unità.That is, it replaces the UNC machine and drive name with the drive letter.

Commenti

I metodi Replace statici sono equivalenti alla costruzione di Regex un oggetto con il modello di espressione regolare specificato e alla chiamata Replacedel metodo di istanza.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Se si specifica RightToLeft per il options parametro, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta verso sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e viene spostata a destra.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Il replacement parametro specifica la stringa che sostituisce ogni corrispondenza in input.The replacement parameter specifies the string that is to replace each match in input. replacementpuò essere costituito da qualsiasi combinazione di testo letterale e sostituzioni.replacement can consist of any combination of literal text and substitutions. Ad esempio, il criterio a*${test}b di sostituzione inserisce la stringa "a *" seguita dalla sottostringa corrispondente al gruppo test di acquisizione, se presente, seguita dalla stringa "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Il carattere * non è riconosciuto come metacarattere in un criterio di sostituzione.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Le sostituzioni sono gli unici elementi del linguaggio di espressioni regolari riconosciuti in un criterio di sostituzione.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

L' RegexMatchTimeoutException eccezione 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.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Note per i chiamanti

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

Vedi anche

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

pattern
String

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

evaluator
MatchEvaluator

Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.A custom method that examines each match and returns either the original matched string or a replacement string.

Restituisce

Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

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

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

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

Esempi

Nell'esempio seguente viene usata un'espressione regolare per estrarre le singole parole da una stringa, quindi viene usato MatchEvaluator un delegato per chiamare un metodo WordScramble denominato che consente di comprimere le singole lettere della parola.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. A tale scopo, il WordScramble metodo crea una matrice contenente i caratteri della corrispondenza.To do this, the WordScramble method creates an array that contains the characters in the match. Viene inoltre creata una matrice parallela che popola con numeri a virgola mobile casuali.It also creates a parallel array that it populates with random floating-point numbers. 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.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. Questa stringa appena creata viene quindi restituita dal WordScramble metodo.This newly created string is then returned by the WordScramble method. Il criterio \w+ di ricerca di espressioni regolari corrisponde a uno o più caratteri alfanumerici. il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza fino a quando non viene rilevato un carattere non alfanumerico, ad esempio un carattere di spazio vuoto.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character.

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 espressione regolare se si verifica una delle condizioni seguenti:The Regex.Replace(String, String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di un'espressione regolare.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.The replacement string results from some processing done on the matched string.

  • Stringa di sostituzione risultante dall'elaborazione condizionale.The replacement string results from conditional processing.

Il metodo equivale Regex.Matches(String, String) a chiamare il metodo e a passare ogni Match oggetto della raccolta restituita MatchCollection al evaluator delegato.The method is equivalent to calling the Regex.Matches(String, String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

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

Il evaluator parametro è il delegato per un metodo personalizzato definito dall'utente e che esamina ogni corrispondenza.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Il metodo personalizzato deve avere la firma seguente per trovare la MatchEvaluator corrispondenza con il delegato.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.Your custom method returns a string that replaces the matched input.

L' RegexMatchTimeoutException eccezione 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.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Note per i chiamanti

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

Vedi anche

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.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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

pattern
String

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

replacement
String

Stringa di sostituzione.The replacement string.

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

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

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

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

Esempi

Nell'esempio seguente viene definita un'espressione regolare \s+,, che corrisponde a uno o più caratteri di spazio vuoto.The following example defines a regular expression, \s+, that matches one or more white-space characters. La stringa di sostituzione, "", li sostituisce con un singolo carattere di spazio.The replacement string, " ", replaces them with a single space character.

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 Replace(String, String, String) il metodo per sostituire il computer locale e i nomi di unità in un percorso UNC con un percorso di file locale.The following example uses the Replace(String, String, String) method to replace the local machine and drive names in a UNC path with a local file path. 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.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. Per eseguire correttamente l'esempio, è necessario sostituire la stringa letterale "computer" con il nome del computer locale.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

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 criterio di ricerca di espressioni regolari è definito dall'espressione seguente:The regular expression pattern is defined by the following expression:

"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.The following table shows how the regular expression pattern is interpreted.

ModelloPattern DescriptionDescription
\\\\ Corrisponde a due caratteri di\barra rovesciata () consecutivi.\\\\ Match two consecutive backslash (\) characters. Poiché il carattere barra rovesciata viene interpretato come carattere di escape, è necessario che ogni barra rovesciata venga preceduta da un'altra barra rovesciata.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
(?i:" + Environment.MachineName + ") Eseguire una corrispondenza senza distinzione tra maiuscole e minuscole della stringa restituita Environment.MachineName dalla proprietà.Perform a case-insensitive match of the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Corrisponde al carattere punto.() seguito da uno o più caratteri alfanumerici.Match the period (.) character followed by one or more word characters. Questa corrispondenza può verificarsi zero o più volte.This match can occur zero or more times. La sottoespressione corrispondente non viene acquisita.The matched subexpression is not captured.
\\ Corrisponde a un carattere\barra rovesciata ().\\ Match a backslash (\) character.
((?i:[" + driveNames + "])) Eseguire una corrispondenza senza distinzione tra maiuscole e minuscole della classe di caratteri costituita dalle singole lettere di unità.Perform a case-insensitive match of the character class that consists of the individual drive letters. Corrisponde alla prima sottoespressione acquisita.This match is the first captured subexpression.
\$ Corrisponde al carattere di segno di$Dollaro ().Match the literal dollar sign ($) character.

Il criterio $1 di sostituzione sostituisce l'intera corrispondenza con la prima sottoespressione acquisita.The replacement pattern $1 replaces the entire match with the first captured subexpression. Ovvero sostituisce il computer UNC e il nome dell'unità con la lettera di unità.That is, it replaces the UNC machine and drive name with the drive letter.

Commenti

I metodi Replace statici sono equivalenti alla costruzione di Regex un oggetto con il modello di espressione regolare specificato e alla chiamata Replacedel metodo di istanza.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

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

Il replacement parametro specifica la stringa che sostituisce ogni corrispondenza in input.The replacement parameter specifies the string that is to replace each match in input. replacementpuò essere costituito da qualsiasi combinazione di testo letterale e sostituzioni.replacement can consist of any combination of literal text and substitutions. Ad esempio, il criterio a*${test}b di sostituzione inserisce la stringa "a *" seguita dalla sottostringa corrispondente al gruppo test di acquisizione, se presente, seguita dalla stringa "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Il carattere * non è riconosciuto come metacarattere in un criterio di sostituzione.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Le sostituzioni sono gli unici elementi del linguaggio di espressioni regolari riconosciuti in un criterio di sostituzione.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

L' RegexMatchTimeoutException eccezione 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.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Note per i chiamanti

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

Vedi anche

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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

replacement
String

Stringa di sostituzione.The replacement string.

count
Int32

Numero massimo di volte in cui la sostituzione può aver luogo.The maximum number of times the replacement can occur.

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

input o replacement è null.input or replacement is null.

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

Esempi

Nell'esempio seguente vengono sostituite le prime cinque occorrenze di caratteri duplicati con un singolo carattere.The following example replaces the first five occurrences of duplicated characters with a single character. Il criterio (\w)\1 di ricerca di espressioni regolari corrisponde a occorrenze consecutive di un singolo carattere e assegna la prima occorrenza al primo gruppo di acquisizione.The regular expression pattern (\w)\1 matches consecutive occurrences of a single character and assigns the first occurrence to the first capturing group. Il criterio $1 di sostituzione sostituisce l'intera corrispondenza con il primo gruppo acquisito.The replacement pattern $1 replaces the entire match with the first captured group.

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 di corrispondenze inizia all'inizio della input stringa.The search for matches starts at the beginning of the input string. L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .The regular expression is the pattern that is defined by the constructor for the current Regex object. Se count è negativo, le sostituzioni continuano fino alla fine della stringa.If count is negative, replacements continue to the end of the string. Se count supera il numero di corrispondenze, verranno sostituite tutte le corrispondenze.If count exceeds the number of matches, all matches are replaced.

Il replacement parametro specifica la stringa che sostituisce le prime count corrispondenze in input.The replacement parameter specifies the string that is to replace the first count matches in input. replacementpuò essere costituito da qualsiasi combinazione di testo letterale e sostituzioni.replacement can consist of any combination of literal text and substitutions. Ad esempio, il criterio a*${test}b di sostituzione inserisce la stringa "a *" seguita dalla sottostringa corrispondente al gruppo test di acquisizione, se presente, seguita dalla stringa "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Il carattere * non è riconosciuto come metacarattere in un criterio di sostituzione.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Le sostituzioni sono gli unici elementi del linguaggio di espressioni regolari riconosciuti in un criterio di sostituzione.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

evaluator
MatchEvaluator

Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.A custom method that examines each match and returns either the original matched string or a replacement string.

Restituisce

Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

input o evaluator è null.input or evaluator is null.

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

Esempi

Nell'esempio di codice seguente viene visualizzata una stringa originale che corrisponde a ogni parola nella stringa originale, converte il primo carattere di ogni corrispondenza in maiuscolo, quindi Visualizza la stringa convertita.The following code example displays an original string, matches each word in the original string, converts the first character of each match to uppercase, then displays the converted string.

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 espressione regolare se si verifica una delle condizioni seguenti:The Regex.Replace(String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di un'espressione regolare.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.The replacement string results from some processing done on the matched string.

  • Stringa di sostituzione risultante dall'elaborazione condizionale.The replacement string results from conditional processing.

Il metodo equivale Regex.Matches(String) a chiamare il metodo e a passare ogni Match oggetto della raccolta restituita MatchCollection al evaluator delegato.The method is equivalent to calling the Regex.Matches(String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .The regular expression is the pattern defined by the constructor for the current Regex object.

Il evaluator parametro è il delegato per un metodo personalizzato definito dall'utente e che esamina ogni corrispondenza.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Il metodo personalizzato deve avere la firma seguente per trovare la MatchEvaluator corrispondenza con il delegato.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.Your custom method returns a string that replaces the matched input.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

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.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

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

replacement
String

Stringa di sostituzione.The replacement string.

Restituisce

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

input o replacement è null.input or replacement is null.

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

Esempi

Nell'esempio seguente viene definita un'espressione regolare \s+,, che corrisponde a uno o più caratteri di spazio vuoto.The following example defines a regular expression, \s+, that matches one or more white-space characters. La stringa di sostituzione, "", li sostituisce con un singolo carattere di spazio.The replacement string, " ", replaces them with a single space character.

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 $2sostituzione,, che rimuove un simbolo di valuta finale o finale da un valore numerico.The following example defines a regular expression, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, and a replacement pattern, $2, that removes either a leading or a trailing currency symbol from a numeric value.

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.The regular expression is interpreted as shown in the following table.

ModelloPattern DescriptionDescription
\p{Sc} Corrisponde a un simbolo di valuta.Match a currency symbol. {Sc}indica qualsiasi carattere membro del simbolo Unicode, categoria di valuta.{Sc} denotes any character that is a member of the Unicode Symbol, Currency category.
\s? Trova la corrispondenza di uno o nessuno spazio vuoto.Match zero or one white-space character.
(\p{Sc}\s?)? Trovare la corrispondenza con zero o una occorrenza della combinazione di un simbolo di valuta seguito da zero o da uno spazio vuoto.Match zero or one occurrence of the combination of a currency symbol followed by zero or one white-space character. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\d+ Trova la corrispondenza con una o più cifre decimali.Match one or more decimal digits.
\.? Trovare la corrispondenza con zero o una occorrenza di un punto (usato come carattere separatore decimale).Match zero or one occurrence of a period (used as a decimal separator character).
((?<=\.)\d+)? Se un punto è il carattere precedente, trovare la corrispondenza con una o più cifre decimali.If a period is the previous character, match one or more decimal digits. Questo modello può corrispondere a zero o una volta.This pattern can be matched either zero or one time.
(\d+\.?((?<=\.)\d+)?) Corrisponde al modello di una o più cifre decimali seguite da un periodo facoltativo e da cifre decimali aggiuntive.Match the pattern of one or more decimal digits followed by an optional period and additional decimal digits. Equivale al secondo gruppo di acquisizione.This is the second capturing group. La chiamata al Replace(String, String) metodo sostituisce l'intera corrispondenza con il valore di questo gruppo acquisito.The call to the Replace(String, String) method replaces the entire match with the value of this captured group.
(?(1)|\s?\p{Sc})? Se il primo gruppo acquisito esiste, trovare la corrispondenza con una stringa vuota.If the first captured group exists, match an empty string. In caso contrario, trovare la corrispondenza con zero o un carattere di spazio vuoto seguito da un simbolo di valuta.Otherwise, match zero or one white-space character followed by a currency symbol.

Commenti

La ricerca di corrispondenze inizia all'inizio della input stringa.The search for matches starts at the beginning of the input string. L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .The regular expression is the pattern defined by the constructor for the current Regex object.

Il replacement parametro specifica la stringa che sostituisce ogni corrispondenza in input.The replacement parameter specifies the string that is to replace each match in input. replacementpuò essere costituito da qualsiasi combinazione di testo letterale e sostituzioni.replacement can consist of any combination of literal text and substitutions. Ad esempio, il criterio a*${test}b di sostituzione inserisce la stringa "a *" seguita dalla sottostringa corrispondente al gruppo test di acquisizione, se presente, seguita dalla stringa "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Il carattere * non è riconosciuto come metacarattere in un criterio di sostituzione.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Le sostituzioni sono gli unici elementi del linguaggio di espressioni regolari riconosciuti in un criterio di sostituzione.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

evaluator
MatchEvaluator

Metodo personalizzato che esamina ogni corrispondenza e restituisce la stringa corrispondente originale o una stringa di sostituzione.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32

Numero massimo di volte in cui la sostituzione avrà luogo.The maximum number of times the replacement will occur.

Restituisce

Stringa nuova identica alla stringa di input, ad eccezione del fatto che ogni stringa corrispondente viene sostituita da una stringa di sostituzione.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se il criterio di espressione regolare non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Eccezioni

input o evaluator è null.input or evaluator is null.

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

Esempi

Nell'esempio seguente viene usata un'espressione regolare per scrivere intenzionalmente la metà delle parole in un elenco.The following example uses a regular expression to deliberately misspell half of the words in a list. Usa l'espressione \w*(ie|ei)\w* regolare per trovare la corrispondenza con parole che includono i caratteri "IE" o "ei".It uses the regular expression \w*(ie|ei)\w* to match words that include the characters "ie" or "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.It passes the first half of the matching words to the ReverseLetter method, which, in turn, uses the Replace(String, String, String, RegexOptions) method to reverse "i" and "e" in the matched string. Le parole rimanenti restano invariate.The remaining words remain unchanged.

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.The regular expression \w*(ie|ei)\w* is defined as shown in the following table.

ModelloPattern DescriptionDescription
\w* Trova la corrispondenza di zero o più caratteri alfanumerici.Match zero or more word characters.
(ie|ei) Corrisponde a "IE" o "ei".Match either "ie" or "ei".
\w* Trova la corrispondenza di zero o più caratteri alfanumerici.Match zero or more word characters.

Il criterio ([ie])([ie]) di ricerca di espressioni ReverseLetter regolari nel metodo corrisponde alla prima "i" o "e" in dittongo "IE" o "ei" e assegna la lettera al primo gruppo di acquisizione.The regular expression pattern ([ie])([ie]) in the ReverseLetter method matches the first "i" or "e" in the diphthong "ie" or "ei" and assigns the letter to the first capturing group. Corrisponde alla seconda "i" o "e" e assegna la lettera al secondo gruppo di acquisizione.It matches the second "i" or "e" and assigns the letter to the second capturing group. I due caratteri vengono quindi invertiti chiamando il Replace(String, String, String) metodo con il criterio $2$1di sostituzione.The two characters are then reversed by calling the Replace(String, String, String) method with the replacement pattern $2$1.

Commenti

Il Regex.Replace(String, MatchEvaluator, Int32) metodo è utile per sostituire una corrispondenza di espressione regolare se si verifica una delle condizioni seguenti:The Regex.Replace(String, MatchEvaluator, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di un'espressione regolare.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.The replacement string results from some processing done on the matched string.

  • Stringa di sostituzione risultante dall'elaborazione condizionale.The replacement string results from conditional processing.

Il metodo Regex.Matches(String) equivale a chiamare il metodo e a passare i primi count Match oggetti della raccolta restituita MatchCollection al evaluator delegato.The method is equivalent to calling the Regex.Matches(String) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

L'espressione regolare è il modello definito dal costruttore per l'oggetto corrente Regex .The regular expression is the pattern defined by the constructor for the current Regex object.

Il evaluator parametro è il delegato per un metodo personalizzato definito dall'utente e che esamina ogni corrispondenza.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Il metodo personalizzato deve avere la firma seguente per trovare la MatchEvaluator corrispondenza con il delegato.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.Your custom method returns a string that replaces the matched input.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile usare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato sostituzioni alla stringa di input.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Vedi anche

Si applica a