Regex.Replace Metodo

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se pattern non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene usato il metodo Replace(String, String, String, RegexOptions) per sostituire il computer locale e i nomi delle unità in un percorso UNC con un percorso di file locale. L'espressione regolare usa la proprietà Environment.MachineName per includere il nome del computer locale e il metodo Environment.GetLogicalDrives per includere i nomi delle unità logiche. Tutti i confronti tra stringhe di espressioni regolari non fanno distinzione tra maiuscole e minuscole. Per eseguire correttamente l'esempio, sostituire la stringa letterale "MyMachine" con il nome del computer locale.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Il criterio di espressione regolare è definito dall'espressione seguente:

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

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

Il modello di sostituzione $1 sostituisce l'intera corrispondenza con la prima sottoespressione acquisita. Ovvero, sostituisce il computer UNC e il nome dell'unità con la lettera di unità.

Commenti

I metodi Replace statici sono equivalenti a costruire un oggetto Regex con il criterio di espressione regolare specificato e chiamando il metodo dell'istanza Replace.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference. Se si specifica RightToLeft per il parametro options, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.

Il parametro replacement specifica la stringa che deve sostituire ogni corrispondenza in input. replacement può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni . Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione test, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Note per i chiamanti

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

Vedi anche

• RegexOptions
• sostituzioni nelle espressioni regolari
• elementi del linguaggio delle espressioni regolari

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se pattern non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene usato il metodo Replace(String, String, String, RegexOptions, TimeSpan) per sostituire il computer locale e i nomi delle unità in un percorso UNC con un percorso di file locale. L'espressione regolare usa la proprietà Environment.MachineName per includere il nome del computer locale e il metodo Environment.GetLogicalDrives per includere i nomi delle unità logiche. Tutti i confronti tra stringhe di espressioni regolari non fanno distinzione tra maiuscole e minuscole e si verifica un timeout di qualsiasi singola operazione di sostituzione se non è possibile trovare una corrispondenza in 0,5 secondi. Per eseguire correttamente l'esempio, sostituire la stringa letterale "MyMachine" con il nome del computer locale.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Il criterio di espressione regolare è definito dall'espressione seguente:

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

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

Il modello di sostituzione $1 sostituisce l'intera corrispondenza con la prima sottoespressione acquisita. Ovvero, sostituisce il computer UNC e il nome dell'unità con la lettera di unità.

Commenti

I metodi Replace statici sono equivalenti a costruire un oggetto Regex con il criterio di espressione regolare specificato e chiamando il metodo dell'istanza Replace.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference. Se si specifica RightToLeft per il parametro options, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.

Il parametro replacement specifica la stringa che deve sostituire ogni corrispondenza in input. replacement può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni . Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione test, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Note per i chiamanti

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

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

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

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

Vedi anche

• RegexOptions
• sostituzioni nelle espressioni regolari
• elementi del linguaggio delle espressioni regolari
• backtracking nelle espressioni regolari
• Procedure consigliate per le espressioni regolari in .NET

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che una stringa di sostituzione ha il posto di ogni stringa corrispondente. Se il criterio di espressione regolare non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Commenti

Il metodo Regex.Replace(String, MatchEvaluator, Int32, Int32) è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:

• La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di espressioni regolari.
• La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.
• La stringa di sostituzione risulta dall'elaborazione condizionale.

Il metodo equivale a chiamare il metodo Regex.Matches(String, Int32) e passare il primo oggetto countMatch nell'insieme MatchCollection restituito al delegato evaluator.

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

L'espressione regolare è il modello definito dal costruttore per l'oggetto Regex corrente.

Il parametro evaluator è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al delegato MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• MatchEvaluator
• sostituzioni nelle espressioni regolari
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che una stringa di sostituzione ha il posto di ogni stringa corrispondente. Se pattern non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre le singole parole da una stringa e quindi viene usato un delegato MatchEvaluator per chiamare un metodo denominato WordScramble che esegue lo scombusto delle singole lettere nella parola. A tale scopo, il metodo WordScramble crea una matrice contenente i caratteri nella corrispondenza. Crea anche una matrice parallela che popola con numeri a virgola mobile casuali. Le matrici vengono ordinate chiamando il metodo Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) e la matrice ordinata viene fornita come argomento a un costruttore di classe String. Questa stringa appena creata viene quindi restituita dal metodo WordScramble. Il criterio di espressione regolare \w+ corrisponde a uno o più caratteri di parola; il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza fino a quando non rileva un carattere non di parola, ad esempio uno spazio vuoto. La chiamata al metodo Replace(String, String, MatchEvaluator, RegexOptions) include l'opzione RegexOptions.IgnorePatternWhitespace in modo che il commento nel criterio di espressione regolare \w+ # Matches all the characters in a word. venga ignorato dal motore delle espressioni regolari.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Commenti

Il metodo Regex.Replace(String, String, MatchEvaluator, RegexOptions) è utile per sostituire una corrispondenza di un'espressione regolare in se una delle condizioni seguenti è vera:

• La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di espressioni regolari.

• La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.

• La stringa di sostituzione risulta dall'elaborazione condizionale.

Il metodo equivale a chiamare il metodo Regex.Matches(String, String, RegexOptions) e passare ogni oggetto Match nell'insieme MatchCollection restituito al delegato evaluator.

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

Il parametro evaluator è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al delegato MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.

Se si specifica RightToLeft per il parametro options, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• MatchEvaluator
• RegexOptions
• sostituzioni nelle espressioni regolari
• elementi del linguaggio delle espressioni regolari

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se pattern non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre le singole parole da una stringa e quindi viene usato un delegato MatchEvaluator per chiamare un metodo denominato WordScramble che esegue lo scombusto delle singole lettere nella parola. A tale scopo, il metodo WordScramble crea una matrice contenente i caratteri nella corrispondenza. Crea anche una matrice parallela che popola con numeri a virgola mobile casuali. Le matrici vengono ordinate chiamando il metodo Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) e la matrice ordinata viene fornita come argomento a un costruttore di classe String. Questa stringa appena creata viene quindi restituita dal metodo WordScramble. Il criterio di espressione regolare \w+ corrisponde a uno o più caratteri di parola; il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza fino a quando non rileva un carattere non di parola, ad esempio uno spazio vuoto. La chiamata al metodo Replace(String, String, MatchEvaluator, RegexOptions) include l'opzione RegexOptions.IgnorePatternWhitespace in modo che il commento nel criterio di espressione regolare \w+ # Matches all the characters in a word. venga ignorato dal motore delle espressioni regolari.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Commenti

Il metodo Regex.Replace(String, String, MatchEvaluator, RegexOptions) è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:

• Se la stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di espressioni regolari.

• Se la stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.

• Se la stringa di sostituzione risulta dall'elaborazione condizionale.

Il metodo equivale a chiamare il metodo Regex.Matches(String, String, RegexOptions) e passare ogni oggetto Match nell'insieme MatchCollection restituito al delegato evaluator.

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

Il parametro evaluator è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al delegato MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.

Se si specifica RightToLeft per il parametro options, la ricerca delle corrispondenze inizia alla fine della stringa di input e si sposta a sinistra; in caso contrario, la ricerca inizia all'inizio della stringa di input e si sposta a destra.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Note per i chiamanti

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

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

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

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

Vedi anche

• RegexOptions
• sostituzioni nelle espressioni regolari
• elementi del linguaggio delle espressioni regolari
• backtracking nelle espressioni regolari
• Procedure consigliate per le espressioni regolari in .NET

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se il criterio di espressione regolare non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente vengono vuoti tutti gli spazi, ma la prima riga di una stringa. Definisce un criterio di espressione regolare, ^.*$, che corrisponde a una riga di testo, chiama il metodo Match(String) per trovare la corrispondenza con la prima riga della stringa e usa le proprietà Match.Index e Match.Count per determinare la posizione iniziale della seconda riga.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

Il criterio di espressione regolare ^.*$ viene definito come illustrato nella tabella seguente.

La stringa di sostituzione (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) aggiunge una nuova riga prima della stringa corrispondente. Si noti che \n nell'esempio C# viene interpretato come carattere di nuova riga dal compilatore C#; non rappresenta un carattere di escape di espressione regolare.

Commenti

La ricerca delle corrispondenze inizia nella stringa input nella posizione specificata dal parametro startat. L'espressione regolare è il modello definito dal costruttore per l'oggetto Regex corrente. Se count è negativo, le sostituzioni continuano alla fine della stringa. Se count supera il numero di corrispondenze, tutte le corrispondenze vengono sostituite.

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

Il parametro replacement specifica la stringa che deve sostituire ogni corrispondenza in input. replacement può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni . Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione test, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• sostituzioni nelle espressioni regolari
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se pattern non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene definita un'espressione regolare, \s+, che corrisponde a uno o più caratteri di spazio vuoto. La stringa di sostituzione , " ", li sostituisce con un singolo carattere di spazio.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Nell'esempio seguente viene usato il metodo Replace(String, String, String) per sostituire il computer locale e i nomi delle unità in un percorso UNC con un percorso di file locale. L'espressione regolare usa la proprietà Environment.MachineName per includere il nome del computer locale e il metodo Environment.GetLogicalDrives per includere i nomi delle unità logiche. Per eseguire correttamente l'esempio, sostituire la stringa letterale "MyMachine" con il nome del computer locale.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Il criterio di espressione regolare è definito dall'espressione seguente:

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

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

Il modello di sostituzione $1 sostituisce l'intera corrispondenza con la prima sottoespressione acquisita. Ovvero, sostituisce il computer UNC e il nome dell'unità con la lettera di unità.

Commenti

I metodi Replace statici sono equivalenti a costruire un oggetto Regex con il criterio di espressione regolare specificato e chiamando il metodo dell'istanza Replace.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference. La ricerca delle corrispondenze inizia all'inizio della stringa input.

Il parametro replacement specifica la stringa che deve sostituire ogni corrispondenza in input. replacement può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni . Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione test, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Note per i chiamanti

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

Vedi anche

• sostituzioni nelle espressioni regolari
• elementi del linguaggio delle espressioni regolari

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che una stringa di sostituzione ha il posto di ogni stringa corrispondente. Se pattern non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre le singole parole da una stringa e quindi viene usato un delegato MatchEvaluator per chiamare un metodo denominato WordScramble che esegue lo scombusto delle singole lettere nella parola. A tale scopo, il metodo WordScramble crea una matrice contenente i caratteri nella corrispondenza. Crea anche una matrice parallela che popola con numeri a virgola mobile casuali. Le matrici vengono ordinate chiamando il metodo Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) e la matrice ordinata viene fornita come argomento a un costruttore di classe String. Questa stringa appena creata viene quindi restituita dal metodo WordScramble. Il criterio di espressione regolare \w+ corrisponde a uno o più caratteri di parola; il motore delle espressioni regolari continuerà ad aggiungere caratteri alla corrispondenza fino a quando non rileva un carattere non di parola, ad esempio uno spazio vuoto.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Commenti

Il metodo Regex.Replace(String, String, MatchEvaluator) è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:

• La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di espressioni regolari.

• La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.

• La stringa di sostituzione risulta dall'elaborazione condizionale.

Il metodo equivale a chiamare il metodo Regex.Matches(String, String) e passare ogni oggetto Match nell'insieme MatchCollection restituito al delegato evaluator.

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

Il parametro evaluator è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al delegato MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Note per i chiamanti

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

Vedi anche

• MatchEvaluator
• sostituzioni nelle espressioni regolari
• elementi del linguaggio delle espressioni regolari

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se il criterio di espressione regolare non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente vengono sostituite le prime cinque occorrenze di caratteri duplicati con un singolo carattere. Il criterio di espressione regolare (\w)\1 corrisponde a occorrenze consecutive di un singolo carattere e assegna la prima occorrenza al primo gruppo di acquisizione. Il modello di sostituzione $1 sostituisce l'intera corrispondenza con il primo gruppo acquisito.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

Commenti

La ricerca delle corrispondenze inizia all'inizio della stringa input. L'espressione regolare è il modello definito dal costruttore per l'oggetto Regex corrente. Se count è negativo, le sostituzioni continuano alla fine della stringa. Se count supera il numero di corrispondenze, tutte le corrispondenze vengono sostituite.

Il parametro replacement specifica la stringa che sostituisce la prima corrispondenza count in input. replacement può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni . Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione test, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• linguaggio delle espressioni regolari - di riferimento rapido
• sostituzioni nelle espressioni regolari

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che una stringa di sostituzione ha il posto di ogni stringa corrispondente. Se il criterio di espressione regolare non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio di codice seguente viene visualizzata una stringa originale, che corrisponde a ogni parola nella stringa originale, converte il primo carattere di ogni corrispondenza in maiuscolo e quindi visualizza la stringa convertita.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        Console.WriteLine($"text=[{text}]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]

Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

Commenti

Il metodo Regex.Replace(String, MatchEvaluator) è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:

• La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di espressioni regolari.

• La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.

• La stringa di sostituzione risulta dall'elaborazione condizionale.

Il metodo equivale a chiamare il metodo Regex.Matches(String) e passare ogni oggetto Match nell'insieme MatchCollection restituito al delegato evaluator.

L'espressione regolare è il modello definito dal costruttore per l'oggetto Regex corrente.

Il parametro evaluator è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al delegato MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• MatchEvaluator
• sostituzioni nelle espressioni regolari
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che la stringa di sostituzione ha il posto di ogni stringa corrispondente. Se il criterio di espressione regolare non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene definita un'espressione regolare, \s+, che corrisponde a uno o più caratteri di spazio vuoto. La stringa di sostituzione , " ", li sostituisce con un singolo carattere di spazio.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Nell'esempio seguente viene definita un'espressione regolare, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?e un criterio di sostituzione, $2, che rimuove un simbolo di valuta iniziale o finale da un valore numerico.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

L'espressione regolare viene interpretata come illustrato nella tabella seguente.

Commenti

La ricerca delle corrispondenze inizia all'inizio della stringa input. L'espressione regolare è il modello definito dal costruttore per l'oggetto Regex corrente.

Il parametro replacement specifica la stringa che deve sostituire ogni corrispondenza in input. replacement può essere costituito da qualsiasi combinazione di testo letterale e sostituzioni . Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "a*" seguita dalla sottostringa corrispondente al gruppo di acquisizione test, se presente, seguita dalla stringa "b". Il carattere * non viene riconosciuto come metacaracter all'interno di un modello di sostituzione.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• linguaggio delle espressioni regolari - di riferimento rapido
• sostituzioni nelle espressioni regolari

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

Origine:

Regex.Replace.cs

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

Restituisce

Nuova stringa identica alla stringa di input, ad eccezione del fatto che una stringa di sostituzione ha il posto di ogni stringa corrispondente. Se il criterio di espressione regolare non corrisponde nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Eccezioni

Esempio

Nell'esempio seguente viene utilizzata un'espressione regolare per eseguire deliberatamente un errore di ortografia metà delle parole in un elenco. Usa l'espressione regolare \w*(ie|ei)\w* per trovare le corrispondenze con parole che includono i caratteri "ie" o "ei". Passa la prima metà delle parole corrispondenti al metodo ReverseLetter, che a sua volta usa il metodo Replace(String, String, String, RegexOptions) per invertire "i" e "e" nella stringa corrispondente. Le parole rimanenti rimangono invariate.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

L'espressione regolare \w*(ie|ei)\w* viene definita come illustrato nella tabella seguente.

Il criterio di espressione regolare ([ie])([ie]) nel metodo ReverseLetter corrisponde al primo "i" o "e" nel diphthong "ie" o "ei" e assegna la lettera al primo gruppo di acquisizione. Corrisponde al secondo "i" o "e" e assegna la lettera al secondo gruppo di acquisizione. I due caratteri vengono quindi invertiti chiamando il metodo Replace(String, String, String) con il criterio di sostituzione $2$1.

Commenti

Il metodo Regex.Replace(String, MatchEvaluator, Int32) è utile per sostituire una corrispondenza di un'espressione regolare se una delle condizioni seguenti è vera:

• La stringa di sostituzione non può essere specificata facilmente da un criterio di sostituzione di espressioni regolari.

• La stringa di sostituzione risulta da un'elaborazione eseguita sulla stringa corrispondente.

• La stringa di sostituzione risulta dall'elaborazione condizionale.

Il metodo equivale a chiamare il metodo Regex.Matches(String) e passare il primo oggetto countMatch nell'insieme MatchCollection restituito al delegato evaluator.

L'espressione regolare è il modello definito dal costruttore per l'oggetto Regex corrente.

Il parametro evaluator è il delegato per un metodo personalizzato definito e che esamina ogni corrispondenza. Il metodo personalizzato deve avere la firma seguente per corrispondere al delegato MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Il metodo personalizzato restituisce una stringa che sostituisce l'input corrispondente.

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

Poiché il metodo restituisce input invariato se non esiste alcuna corrispondenza, è possibile utilizzare il metodo Object.ReferenceEquals per determinare se il metodo ha apportato sostituzioni alla stringa di input.

Vedi anche

• MatchEvaluator
• sostituzioni nelle espressioni regolari
• linguaggio delle espressioni regolari - di riferimento rapido