Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Regex.Replace (String, String, String)

 

Data di pubblicazione: novembre 2016

In una stringa di input specificata, sostituisce tutte le stringhe corrispondenti a un'espressione regolare specificata con una stringa di sostituzione specificata.

Spazio dei nomi:   System.Text.RegularExpressions
Assembly:  System (in System.dll)

public static string Replace(
	string input,
	string pattern,
	string replacement
)

Parametri

input
Type: System.String

Stringa nella quale cercare una corrispondenza.

pattern
Type: System.String

Criterio di espressione regolare di cui trovare la corrispondenza.

replacement
Type: System.String

Stringa di sostituzione.

Valore restituito

Type: System.String

Stringa nuova identica alla stringa di input, a eccezione del fatto che ogni stringa corrispondente viene sostituita dalla stringa di sostituzione. Se pattern non trova corrispondenza nell'istanza corrente, il metodo restituisce l'istanza corrente invariata.

Exception Condition
ArgumentException

Si è verificato un errore di analisi dell'espressione regolare.

ArgumentNullException

input, pattern o replacement è null.

RegexMatchTimeoutException

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

Il metodo statico Replace metodi sono equivalenti alla costruzione di un Regex dell'oggetto con il modello di espressione regolare specificata e la chiamata al metodo di istanza Replace.

Il pattern parametro consiste di elementi di linguaggio di espressioni regolari che descrivono la stringa da confrontare. Per ulteriori informazioni sulle espressioni regolari, vedere Espressioni regolari di .NET Framework e Linguaggio di espressioni regolari - Riferimento rapido. La ricerca di corrispondenze inizia all'inizio del input stringa.

Il replacement parametro specifica la stringa da sostituire ogni corrispondenza nella input. replacement può contenere qualsiasi combinazione di testo letterale e sostituzioni. Ad esempio, il criterio di sostituzione a*${test}b inserisce la stringa "un *" seguita dalla sottostringa corrispondente la test gruppo di acquisizione, se presente, seguito dalla stringa "b". Il * carattere non è riconosciuto come metacarattere all'interno di un criterio di sostituzione.

System_CAPS_noteNota

Le sostituzioni sono elementi del linguaggio di espressione regolare solo riconosciuti in un criterio di sostituzione. Tutti gli elementi di linguaggio altre espressioni regolari, tra cui caratteri di escape, sono consentiti nelle solo i modelli di espressione regolare e non sono riconosciuti nei modelli di sostituzione.

Il 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. Se il timeout non viene definito nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, viene generata alcuna eccezione.

Poiché il metodo restituisce input verrà modificato se non esiste alcuna corrispondenza, è possibile utilizzare il Object.ReferenceEquals metodo per determinare se il metodo ha effettuato le sostituzioni di stringa di input.

Note per i chiamanti:

Questo metodo scade dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato. Se non è stato definito un valore di timeout per il dominio applicazione, il valore Regex.InfiniteMatchTimeout, timeout, che impedisce il metodo viene utilizzato. Il metodo statico consigliato per la sostituzione di un criterio di ricerca è Regex.Replace(String, String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

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

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "whitespace.";
      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   whitespace.
//       Replacement String: This is text with far too much whitespace.

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

using System;
using System.Text.RegularExpressions;

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

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 

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

Il modello di espressione regolare viene definito dalla seguente espressione:

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

Nella tabella seguente è illustrata l'interpretazione del criterio di ricerca di espressioni regolari.

Criterio

Descrizione

\\\\

Barra rovesciata consecutivo corrispondenza due (\) caratteri. Poiché il carattere barra rovesciata viene interpretato come carattere di escape, ogni barra rovesciata deve essere preceduta da un'altra barra rovesciata.

(?i:" + Environment.MachineName + ")

Eseguire una corrispondenza tra maiuscole e minuscole della stringa restituita dalla Environment.MachineName proprietà.

(?:\.\w+)*

Corrispondono al periodo (.) carattere seguito da uno o più caratteri alfanumerici. Questa corrispondenza può verificarsi zero o più volte. La sottoespressione corrispondente non viene acquisita.

\\

Corrisponde a una barra rovesciata (\) caratteri.

((?i:[" + driveNames + "]))

Eseguire una corrispondenza tra maiuscole e minuscole della classe di caratteri costituito da lettere di unità singola. Questa corrispondenza è la prima sottoespressione acquisita.

\$

Corrispondenza del simbolo del dollaro letterale ($) caratteri.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: