Regex.Replace Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Text.RegularExpressions

Zestaw:: System.Text.RegularExpressions.dll

Zestaw:: System.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

W określonym ciągu wejściowym zastępuje ciągi zgodne ze wzorcem wyrażenia regularnego określonym ciągiem zastępczym.

Przeciążenia

Replace(String, MatchEvaluator, Int32, Int32)	W określonym podciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, String, String)	W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego określonym ciągiem zastępczym.
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)	W określonym ciągu wejściowym zastępuje wszystkie podciągy zgodne z określonym wyrażeniem regularnym ciągiem zwracanym przez delegata MatchEvaluator . Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.
Replace(String, String, MatchEvaluator, RegexOptions)	W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator . Określone opcje modyfikują zgodną operację.
Replace(String, String, String, RegexOptions, TimeSpan)	W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego określonym ciągiem zastępczym. Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.
Replace(String, String, String, RegexOptions)	W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego określonym ciągiem zastępczym. Określone opcje modyfikują zgodną operację.
Replace(String, MatchEvaluator)	W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, MatchEvaluator, Int32)	W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, String, MatchEvaluator)	W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .
Replace(String, String, Int32)	W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego określonym ciągiem zastępczym.
Replace(String, String)	W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne ze wzorcem wyrażenia regularnego określonym ciągiem zastępczym.
Replace(String, String, Int32, Int32)	W określonym podciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego określonym ciągiem zastępczym.

Replace(String, MatchEvaluator, Int32, Int32)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym podciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parametry

input: String

Ciąg do wyszukania dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny dopasowany ciąg lub ciąg zastępczy.

count: Int32

Maksymalna liczba wystąpień zamiany.

startat: Int32

Pozycja znaku w ciągu wejściowym, w którym rozpoczyna się wyszukiwanie.

Zwraca

String

Nowy ciąg, który jest identyczny z ciągiem wejściowym, z tą różnicą, że ciąg zastępczy ma miejsce każdego dopasowanego ciągu. Jeśli wzorzec wyrażenia regularnego nie jest zgodny w bieżącym wystąpieniu, metoda zwraca bieżące wystąpienie bez zmian.

Wyjątki

ArgumentNullException

input lub evaluator ma wartość null.

ArgumentOutOfRangeException

startat jest mniejsza niż zero lub większa niż długość input.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

Metoda jest przydatna Regex.Replace(String, MatchEvaluator, Int32, Int32) do zastępowania dopasowania wyrażenia regularnego, jeśli którykolwiek z następujących warunków jest spełniony:

Ciąg zastępczy nie może być łatwo określony przez wzorzec zamiany wyrażeń regularnych.
Ciąg zastępczy wynika z przetwarzania wykonanego w dopasowanym ciągu.
Ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu Regex.Matches(String, Int32) metody i przekazaniu pierwszych countMatch obiektów w zwróconej MatchCollection kolekcji do delegata evaluator .

Aby uzyskać więcej informacji na temat startatprogramu , zobacz sekcję Uwagi w temacie Match(String, Int32).

Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktora dla bieżącego Regex obiektu.

Parametr evaluator jest pełnomocnikiem zdefiniowanej metody niestandardowej i sprawdza każde dopasowanie. Metoda niestandardowa musi mieć następujący podpis, aby dopasować go do delegata MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metoda niestandardowa zwraca ciąg, który zastępuje dopasowane dane wejściowe.

Wyjątek RegexMatchTimeoutException jest zgłaszany, jeśli czas wykonywania operacji zamiany przekracza interwał limitu czasu określony przez konstruktora Regex.Regex(String, RegexOptions, TimeSpan) . Jeśli nie ustawisz interwału limitu czasu podczas wywoływania konstruktora, wyjątek jest zgłaszany, jeśli operacja przekroczy wartość limitu czasu ustanowioną dla domeny aplikacji, w której Regex jest tworzony obiekt. Jeśli limit czasu nie jest zdefiniowany w Regex wywołaniu konstruktora lub we właściwościach domeny aplikacji lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie jest zgłaszany wyjątek

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, można użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy

Replace(String, String, String)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

replacement: String

Ciąg zastępujący.

Zwraca

String

Nowy ciąg, który jest identyczny z ciągiem wejściowym, z wyjątkiem tego, że ciąg zastępczy ma miejsce każdego dopasowanego ciągu. Jeśli pattern w bieżącym wystąpieniu nie jest dopasowana, metoda zwraca bieżące wystąpienie bez zmian.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input, patternlub replacement to null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

W poniższym przykładzie zdefiniowano wyrażenie regularne , \s+które pasuje do co najmniej jednego znaku odstępu. Ciąg zastępczy " " zastępuje je pojedynczym znakiem spacji.

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.

W poniższym przykładzie użyto Replace(String, String, String) metody , aby zastąpić nazwy maszyny lokalnej i dysków w ścieżce UNC lokalną ścieżką pliku. Wyrażenie regularne używa Environment.MachineName właściwości do uwzględnienia nazwy komputera lokalnego i Environment.GetLogicalDrives metody w celu uwzględnienia nazw dysków logicznych. Aby pomyślnie uruchomić przykład, należy zastąpić ciąg literału "MyMachine" nazwą komputera lokalnego.

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

Wzorzec wyrażenia regularnego jest definiowany przez następujące wyrażenie:

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

W poniższej tabeli przedstawiono sposób interpretowania wzorca wyrażenia regularnego.

Wzorce	Opis
`\\\\`	Dopasuj dwa kolejne znaki ukośnika odwrotnego (`\`). Ponieważ znak ukośnika odwrotnego jest interpretowany jako znak ucieczki, każdy ukośnik odwrotny musi zostać uniknięty innym ukośnikiem odwrotnym.
`(?i:" + Environment.MachineName + ")`	Wykonaj dopasowanie bez uwzględniania wielkości liter dla ciągu, który jest zwracany przez Environment.MachineName właściwość .
`(?:\.\w+)*`	Dopasuj znak kropki (`.`), po którym następuje co najmniej jeden znak słowa. To dopasowanie może wystąpić zero lub więcej razy. Dopasowane podwyrażenie nie jest przechwytywane.
`\\`	Dopasuj ukośnik odwrotny (`\`).
`((?i:[" + driveNames + "]))`	Wykonaj dopasowanie bez uwzględniania wielkości liter klasy znaków składającej się z pojedynczych liter dysku. To dopasowanie jest pierwszym przechwyconym podwyrażeniem.
`\$`	Dopasuj znak literału dolara (`$`).

Wzorzec $1 zamiany zastępuje całe dopasowanie pierwszym przechwyconym podwyrażeniem. Oznacza to, że zastępuje maszynę UNC i nazwę dysku literą dysku.

Uwagi

Metody statyczne Replace są równoważne konstruowaniu Regex obiektu z określonym wzorcem wyrażenia regularnego i wywoływaniem metody Replacewystąpienia .

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions and Regular Expression Language - Quick Reference (Wyrażenia regularne platformy .NET i język wyrażeń regularnych — krótki przewodnik). Wyszukiwanie dopasowań rozpoczyna się na początku input ciągu.

Parametr replacement określa ciąg, który ma zastąpić każde dopasowanie w .input replacement może składać się z dowolnej kombinacji tekstu literału i podstawień. Na przykład wzorzec a*${test}b zastępczy wstawia ciąg "a*", a następnie podciąg dopasowany przez test grupę przechwytywania, jeśli istnieje, a następnie ciąg "b". Znak * nie jest rozpoznawany jako metacharacter w ramach wzorca zastępczego.

Uwaga

Podstawienia to jedyne elementy języka wyrażeń regularnych rozpoznawane we wzorcu zastępczym. Wszystkie inne elementy języka wyrażeń regularnych, w tym ucieczki znaków, są dozwolone tylko w wzorcach wyrażeń regularnych i nie są rozpoznawane w wzorcach zastępczych.

Wyjątek RegexMatchTimeoutException jest zgłaszany, jeśli czas wykonywania operacji zastępczej przekracza interwał limitu czasu określony dla domeny aplikacji, w której wywoływana jest metoda. Jeśli w właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie zostanie zgłoszony wyjątek.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Uwagi dotyczące wywoływania

Ta metoda powoduje przekroczenie limitu czasu po interwale równym domyślnej wartości limitu czasu domeny aplikacji, w której jest wywoływana. Jeśli wartość limitu czasu nie została zdefiniowana dla domeny aplikacji, zostanie użyta wartość InfiniteMatchTimeout, która uniemożliwia przekroczenie limitu czasu metody. Zalecaną metodą statyczną zastępowania dopasowania wzorca jest Replace(String, String, String, RegexOptions, TimeSpan), która umożliwia ustawienie interwału limitu czasu.

Zobacz też

Dotyczy

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie podciągy zgodne z określonym wyrażeniem regularnym ciągiem zwróconym przez delegata MatchEvaluator . Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny pasujący ciąg lub ciąg zastępczy.

options: RegexOptions

Bitowa kombinacja wartości wyliczenia, które zapewniają opcje dopasowania.

matchTimeout: TimeSpan

Interwał limitu czasu lub InfiniteMatchTimeout wskazujący, że metoda nie powinna upłynął limit czasu.

Zwraca

String

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input, patternlub evaluator to null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitów RegexOptions wartości.

-lub-

matchTimeout jest ujemna, zero lub większa niż około 24 dni.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

W poniższym przykładzie użyto wyrażenia regularnego, aby wyodrębnić poszczególne wyrazy z ciągu, a następnie użyć delegata MatchEvaluator do wywołania metody o nazwie WordScramble , która prześcignie poszczególne litery w słowie. W tym WordScramble celu metoda tworzy tablicę zawierającą znaki w dopasowaniu. Tworzy również tablicę równoległą wypełnianą losowymi liczbami zmiennoprzecinkowymi. Tablice są sortowane przez wywołanie Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metody, a posortowana tablica jest dostarczana jako argument do konstruktora String klasy. Ten nowo utworzony ciąg jest następnie zwracany przez metodę WordScramble . Wzorzec \w+ wyrażenia regularnego jest zgodny z co najmniej jednym znakiem wyrazu. Aparat wyrażeń regularnych będzie nadal dodawać znaki do dopasowania, dopóki nie napotka znaku innego niż wyraz, takiego jak znak odstępu. Wywołanie Replace(String, String, MatchEvaluator, RegexOptions) metody zawiera RegexOptions.IgnorePatternWhitespace opcję , aby komentarz we wzorcu \w+ # Matches all the characters in a word. wyrażenia regularnego był ignorowany przez aparat wyrażeń regularnych.

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

Uwagi

Metoda jest przydatna Regex.Replace(String, String, MatchEvaluator, RegexOptions) do zastępowania dopasowania wyrażenia regularnego, jeśli którykolwiek z następujących warunków jest spełniony:

Jeśli ciąg zastępczy nie może być łatwo określony przez wzorzec wymiany wyrażeń regularnych.
Jeśli ciąg zastępczy wynika z przetwarzania wykonanego na dopasowanym ciągu.
Jeśli ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu Regex.Matches(String, String, RegexOptions) metody i przekazaniu każdego Match obiektu w zwróconej MatchCollection kolekcji do delegata evaluator .

Parametr evaluator jest delegatem metody niestandardowej, która definiuje i sprawdza każde dopasowanie. Metoda niestandardowa musi mieć następujący podpis, aby był zgodny z delegatem MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metoda niestandardowa zwraca ciąg, który zastępuje dopasowane dane wejściowe.

Jeśli określisz RightToLeftoptions parametr, wyszukiwanie dopasowań rozpoczyna się na końcu ciągu wejściowego i przenosi się w lewo. W przeciwnym razie wyszukiwanie rozpoczyna się od początku ciągu wejściowego i przenosi się w prawo.

Parametr matchTimeout określa, jak długo metoda dopasowywania wzorca powinna spróbować znaleźć dopasowanie przed upływem limitu czasu. Ustawienie interwału przekroczenia limitu czasu uniemożliwia wyrażeniem regularnym, które polegają na nadmiernym wycofywaniu, jest wyświetlane jako "przestań odpowiadać, gdy przetwarzają dane wejściowe zawierające niemal dopasowania. Aby uzyskać więcej informacji, zobacz Najlepsze rozwiązania dotyczące wyrażeń regularnych i wycofywania. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda zgłasza RegexMatchTimeoutException wyjątek. matchTimeout zastępuje dowolną domyślną wartość limitu czasu zdefiniowaną dla domeny aplikacji, w której jest wykonywana metoda.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Uwagi dotyczące wywoływania

Zalecamy ustawienie parametru matchTimeout na odpowiednią wartość, taką jak dwie sekundy. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeoutwartość , aparat wyrażeń regularnych zapewnia nieco lepszą wydajność. Należy jednak wyłączyć limity czasu tylko w następujących warunkach:

Gdy dane wejściowe przetwarzane przez wyrażenie regularne pochodzą ze znanego i zaufanego źródła lub składają się z tekstu statycznego. Wyklucza to tekst, który został dynamicznie wprowadzany przez użytkowników.
Gdy wzorzec wyrażenia regularnego został dokładnie przetestowany, aby upewnić się, że efektywnie obsługuje dopasowania, niezgodne i zbliżające się dopasowania.
Gdy wzorzec wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane do nadmiernego wycofywania podczas przetwarzania niemal zgodnego.

Zobacz też

Dotyczy

Replace(String, String, MatchEvaluator, RegexOptions)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym ciągiem zwracanym przez delegata MatchEvaluator . Określone opcje modyfikują odpowiednią operację.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny pasujący ciąg lub ciąg zastępczy.

options: RegexOptions

Bitowa kombinacja wartości wyliczenia, które zapewniają opcje dopasowania.

Zwraca

String

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input, patternlub evaluator to null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitów RegexOptions wartości.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

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

Uwagi

Ciąg zastępczy nie może być łatwo określony przez wzorzec wymiany wyrażeń regularnych.
Ciąg zastępczy wynika z przetwarzania wykonanego w dopasowanym ciągu.
Ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu Regex.Matches(String, String, RegexOptions) metody i przekazaniu każdego Match obiektu w zwróconej MatchCollection kolekcji do delegata evaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metoda niestandardowa zwraca ciąg, który zastępuje dopasowane dane wejściowe.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy

Replace(String, String, String, RegexOptions, TimeSpan)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego określonym ciągiem zastępczym. Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

replacement: String

Ciąg zastępujący.

options: RegexOptions

Bitowa kombinacja wartości wyliczenia, które zapewniają opcje dopasowania.

matchTimeout: TimeSpan

Interwał limitu czasu lub InfiniteMatchTimeout wskazujący, że metoda nie powinna upłynął limit czasu.

Zwraca

String

Nowy ciąg, który jest identyczny z ciągiem wejściowym, z tą różnicą, że ciąg zastępczy ma miejsce każdego dopasowanego ciągu. Jeśli pattern nie jest ono zgodne w bieżącym wystąpieniu, metoda zwraca bieżące wystąpienie bez zmian.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input, patternlub replacement to null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitów RegexOptions wartości.

-lub-

matchTimeout jest ujemna, zero lub większa niż około 24 dni.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

W poniższym przykładzie użyto Replace(String, String, String, RegexOptions, TimeSpan) metody , aby zastąpić nazwy maszyny lokalnej i dysków w ścieżce UNC lokalną ścieżką pliku. Wyrażenie regularne używa Environment.MachineName właściwości , aby dołączyć nazwę komputera lokalnego i Environment.GetLogicalDrives metodę do uwzględnienia nazw dysków logicznych. Wszystkie porównania ciągów wyrażeń regularnych są niewrażliwe na wielkość liter, a w przypadku znalezienia dopasowania w ciągu 0,5 sekundy zostanie upłynął limit czasu każdej operacji zamiany. Aby pomyślnie uruchomić przykład, należy zastąpić ciąg literału "MyMachine" nazwą komputera lokalnego.

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

Wzorzec wyrażenia regularnego jest definiowany przez następujące wyrażenie:

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

W poniższej tabeli przedstawiono sposób interpretowania wzorca wyrażenia regularnego.

Wzorce	Opis
`\\\\`	Dopasuj dwa kolejne znaki ukośnika odwrotnego (`\`). Ponieważ znak ukośnika odwrotnego jest interpretowany jako znak ucieczki, każdy ukośnik odwrotny musi zostać uniknięty innym ukośnikiem odwrotnym.
`+ Environment.MachineName +`	Dopasuj ciąg zwracany przez Environment.MachineName właściwość .
`(?:\.\w+)*`	Dopasuj znak kropki (`.`), po którym następuje co najmniej jeden znak słowa. To dopasowanie może wystąpić zero lub więcej razy. Dopasowane podwyrażenie nie jest przechwytywane.
`\\`	Dopasuj ukośnik odwrotny (`\`).
`([" + driveNames + "])`	Dopasuj klasę znaków składającą się z pojedynczych liter dysku. To dopasowanie jest pierwszym przechwyconym podwyrażeniem.
`\$`	Dopasuj znak literału dolara (`$`).

Wzorzec $1 zamiany zastępuje całe dopasowanie pierwszym przechwyconym podwyrażeniem. Oznacza to, że zastępuje maszynę UNC i nazwę dysku literą dysku.

Uwagi

Metody statyczne Replace są równoważne konstruowaniu Regex obiektu z określonym wzorcem wyrażenia regularnego i wywoływaniem metody Replacewystąpienia .

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions and Regular Expression Language - Quick Reference (Wyrażenia regularne platformy .NET i język wyrażeń regularnych — krótki przewodnik). Jeśli określisz RightToLeft parametr options , wyszukiwanie dopasowań rozpoczyna się od końca ciągu wejściowego i przenosi się w lewo. W przeciwnym razie wyszukiwanie rozpoczyna się od początku ciągu wejściowego i przenosi się w prawo.

Parametr replacement określa ciąg, który ma zastąpić każde dopasowanie w .input replacement może składać się z dowolnej kombinacji tekstu literału i podstawień. Na przykład wzorzec a*${test}b zastępczy wstawia ciąg "a*", po którym następuje podciąg dopasowany przez test grupę przechwytywania, jeśli istnieje, a następnie ciąg "b". Znak * nie jest rozpoznawany jako metatyp w ramach wzorca zastępczego.

Uwaga

Podstawienia to jedyne elementy języka wyrażeń regularnych, które są rozpoznawane we wzorcu zastępczym. Wszystkie inne elementy języka wyrażeń regularnych, w tym znaki ucieczki, są dozwolone tylko we wzorcach wyrażeń regularnych i nie są rozpoznawane we wzorcach zastępczych.

Parametr matchTimeout określa, jak długo metoda dopasowania wzorca powinna próbować znaleźć dopasowanie przed upływem limitu czasu. Ustawienie interwału przekroczenia limitu czasu uniemożliwia wyrażenia regularne, które polegają na nadmiernym wycofywaniu, aby przestać odpowiadać podczas przetwarzania danych wejściowych, które zawierają niemal dopasowania. Aby uzyskać więcej informacji, zobacz Best Practices for Regular Expressions and Backtracking (Najlepsze rozwiązania dotyczące wyrażeń regularnych i wycofywania). Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda zgłasza RegexMatchTimeoutException wyjątek. matchTimeout zastępuje dowolną domyślną wartość limitu czasu zdefiniowaną dla domeny aplikacji, w której jest wykonywana metoda.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, można użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Uwagi dotyczące wywoływania

Zalecamy ustawienie parametru matchTimeout na odpowiednią wartość, taką jak dwie sekundy. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeout, aparat wyrażeń regularnych zapewnia nieco lepszą wydajność. Należy jednak wyłączyć limity czasu tylko w następujących warunkach:

Gdy dane wejściowe przetwarzane przez wyrażenie regularne pochodzą ze znanego i zaufanego źródła lub składa się z tekstu statycznego. Wyklucza to tekst, który został dynamicznie wprowadzany przez użytkowników.
Gdy wzorzec wyrażenia regularnego został dokładnie przetestowany w celu zapewnienia, że efektywnie obsługuje dopasowania, niezgodne i bliskie dopasowania.
Gdy wzorzec wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane z nadmiernego wycofywania podczas przetwarzania zbliżonego dopasowania.

Zobacz też

Dotyczy

Replace(String, String, String, RegexOptions)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym. Określone opcje modyfikują odpowiednią operację.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

replacement: String

Ciąg zastępujący.

options: RegexOptions

Bitowa kombinacja wartości wyliczenia, które zapewniają opcje dopasowania.

Zwraca

String

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input, patternlub replacement to null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitów RegexOptions wartości.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

W poniższym przykładzie użyto Replace(String, String, String, RegexOptions) metody , aby zastąpić nazwy maszyny lokalnej i dysków w ścieżce UNC lokalną ścieżką pliku. Wyrażenie regularne używa Environment.MachineName właściwości do uwzględnienia nazwy komputera lokalnego i Environment.GetLogicalDrives metody w celu uwzględnienia nazw dysków logicznych. Wszystkie porównania ciągów wyrażeń regularnych są bez uwzględniania wielkości liter. Aby pomyślnie uruchomić przykład, należy zastąpić ciąg literału "MyMachine" nazwą komputera lokalnego.

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

Wzorzec wyrażenia regularnego jest definiowany przez następujące wyrażenie:

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

W poniższej tabeli przedstawiono sposób interpretowania wzorca wyrażenia regularnego.

Wzorce	Opis
`\\\\`	Dopasuj dwa kolejne znaki ukośnika odwrotnego (`\`). Ponieważ znak ukośnika odwrotnego jest interpretowany jako znak ucieczki, każdy ukośnik odwrotny musi zostać uniknięty innym ukośnikiem odwrotnym.
`+ Environment.MachineName +`	Dopasuj ciąg zwracany przez Environment.MachineName właściwość .
`(?:\.\w+)*`	Dopasuj znak kropki (`.`), po którym następuje co najmniej jeden znak słowa. To dopasowanie może wystąpić zero lub więcej razy. Dopasowane podwyrażenie nie jest przechwytywane.
`\\`	Dopasuj ukośnik odwrotny (`\`).
`([" + driveNames + "])`	Dopasuj klasę znaków składającą się z pojedynczych liter dysku. To dopasowanie jest pierwszym przechwyconym podwyrażeniem.
`\$`	Dopasuj znak literału dolara (`$`).

Wzorzec $1 zamiany zastępuje całe dopasowanie pierwszym przechwyconym podwyrażeniem. Oznacza to, że zastępuje maszynę UNC i nazwę dysku literą dysku.

Uwagi

Metody statyczne Replace są równoważne konstruowaniu Regex obiektu z określonym wzorcem wyrażenia regularnego i wywoływaniem metody Replacewystąpienia .

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions and Regular Expression Language - Quick Reference (Wyrażenia regularne platformy .NET i język wyrażeń regularnych — krótki przewodnik). Jeśli określisz RightToLeft parametr options , wyszukiwanie dopasowań rozpoczyna się od końca ciągu wejściowego i przenosi się w lewo. W przeciwnym razie wyszukiwanie rozpoczyna się od początku ciągu wejściowego i przenosi się w prawo.

Uwaga

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Replace(String, MatchEvaluator)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne z określonym wyrażeniem regularnym ciągiem zwracanym przez delegata MatchEvaluator .

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Function Replace (input As String, evaluator As MatchEvaluator) As String

Parametry

input: String

Ciąg do wyszukania dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny pasujący ciąg lub ciąg zastępczy.

Zwraca

String

Nowy ciąg, który jest identyczny z ciągiem wejściowym, z wyjątkiem tego, że ciąg zastępczy ma miejsce każdego dopasowanego ciągu. Jeśli wzorzec wyrażenia regularnego nie jest zgodny w bieżącym wystąpieniu, metoda zwraca bieżące wystąpienie bez zmian.

Wyjątki

ArgumentNullException

input lub evaluator to null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

Poniższy przykład kodu wyświetla oryginalny ciąg, pasuje do każdego wyrazu w oryginalnym ciągu, konwertuje pierwszy znak każdego dopasowania na wielkie litery, a następnie wyświetla przekonwertowany ciąg.

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]

Uwagi

Metoda jest przydatna Regex.Replace(String, MatchEvaluator) do zastępowania dopasowania wyrażenia regularnego, jeśli którykolwiek z następujących warunków jest spełniony:

Ciąg zastępczy nie może być łatwo określony przez wzorzec wymiany wyrażeń regularnych.
Ciąg zastępczy wynika z przetwarzania wykonanego w dopasowanym ciągu.
Ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu Regex.Matches(String) metody i przekazaniu każdego Match obiektu w zwróconej MatchCollection kolekcji do delegata evaluator .

Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktora dla bieżącego Regex obiektu.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metoda niestandardowa zwraca ciąg, który zastępuje dopasowane dane wejściowe.

Wyjątek RegexMatchTimeoutException jest zgłaszany, jeśli czas wykonywania operacji zastępczej przekracza interwał limitu czasu określony przez konstruktora Regex.Regex(String, RegexOptions, TimeSpan) . Jeśli nie ustawisz interwału przekroczenia limitu czasu podczas wywoływania konstruktora, wyjątek jest zgłaszany, jeśli operacja przekracza dowolną wartość limitu czasu ustanowioną dla domeny aplikacji, w której Regex jest tworzony obiekt. Jeśli w Regex wywołaniu konstruktora lub we właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie jest zgłaszany żaden wyjątek

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy

Replace(String, MatchEvaluator, Int32)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parametry

input: String

Ciąg do wyszukania dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny pasujący ciąg lub ciąg zastępczy.

count: Int32

Maksymalna liczba wystąpień zamiany.

Zwraca

String

Wyjątki

ArgumentNullException

input lub evaluator to null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

W poniższym przykładzie użyto wyrażenia regularnego, aby celowo przegapić połowę wyrazów na liście. Używa wyrażenia \w*(ie|ei)\w* regularnego do dopasowywania wyrazów zawierających znaki "ie" lub "ei". Przekazuje pierwszą połowę pasujących słów do ReverseLetter metody, która z kolei używa Replace(String, String, String, RegexOptions) metody do odwrócenia ciągu "i" i "e" w dopasowanym ciągu. Pozostałe słowa pozostają niezmienione.

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

Wyrażenie \w*(ie|ei)\w* regularne jest definiowane tak, jak pokazano w poniższej tabeli.

Wzorce	Opis
`\w*`	Dopasowuje zero lub więcej znaków słowa.
`(ie\|ei)`	Dopasuj "ie" lub "ei".
`\w*`	Dopasowuje zero lub więcej znaków słowa.

Wzorzec ([ie])([ie]) wyrażenia regularnego w metodzie ReverseLetter pasuje do pierwszego "i" lub "e" w diphthong "ie" lub "ei" i przypisuje literę do pierwszej grupy przechwytywania. Pasuje do drugiego elementu "i" lub "e" i przypisuje literę do drugiej grupy przechwytywania. Dwa znaki są następnie odwracane przez wywołanie Replace(String, String, String) metody za pomocą wzorca $2$1zastępczego .

Uwagi

Metoda jest przydatna Regex.Replace(String, MatchEvaluator, Int32) do zastępowania dopasowania wyrażenia regularnego, jeśli którykolwiek z następujących warunków jest spełniony:

Ciąg zastępczy nie może być łatwo określony przez wzorzec wymiany wyrażeń regularnych.
Ciąg zastępczy wynika z przetwarzania wykonanego w dopasowanym ciągu.
Ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu Regex.Matches(String) metody i przekazaniu pierwszych countMatch obiektów w zwróconej MatchCollection kolekcji do delegata evaluator .

Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktora dla bieżącego Regex obiektu.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metoda niestandardowa zwraca ciąg, który zastępuje dopasowane dane wejściowe.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy

Replace(String, String, MatchEvaluator)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi pasujące do określonego wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator .

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String

Parametry

input: String

Ciąg do wyszukania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny pasujący ciąg lub ciąg zastępczy.

Zwraca

String

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input, patternlub evaluator to null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

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

Uwagi

Metoda jest przydatna Regex.Replace(String, String, MatchEvaluator) do zastępowania dopasowania wyrażenia regularnego, jeśli którykolwiek z następujących warunków jest spełniony:

Ciąg zastępczy nie może być łatwo określony przez wzorzec wymiany wyrażeń regularnych.
Ciąg zastępczy wynika z przetwarzania wykonanego w dopasowanym ciągu.
Ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu Regex.Matches(String, String) metody i przekazaniu każdego Match obiektu w zwróconej MatchCollection kolekcji do delegata evaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metoda niestandardowa zwraca ciąg, który zastępuje dopasowane dane wejściowe.

Wyjątek RegexMatchTimeoutException jest zgłaszany, jeśli czas wykonywania operacji zamiany przekracza interwał limitu czasu określony dla domeny aplikacji, w której jest wywoływana metoda. Jeśli w właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie zostanie zgłoszony wyjątek.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, można użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Uwagi dotyczące wywoływania

Ta metoda powoduje przekroczenie limitu czasu po interwale równym domyślnej wartości limitu czasu domeny aplikacji, w której jest wywoływana. Jeśli dla domeny aplikacji nie zdefiniowano wartości limitu czasu, zostanie użyta wartość InfiniteMatchTimeout, która uniemożliwia przekroczenie limitu czasu metody. Zalecaną metodą statyczną do obliczania i zastępowania dopasowania wzorca jest Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), która umożliwia ustawienie interwału przekroczenia limitu czasu.

Zobacz też

Dotyczy

Replace(String, String, Int32)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego określonym ciągiem zastępczym.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

replacement: String

Ciąg zastępujący.

count: Int32

Maksymalna liczba wystąpień zamiany.

Zwraca

String

Wyjątki

ArgumentNullException

input lub replacement ma wartość null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

Poniższy przykład zastępuje pięć pierwszych wystąpień zduplikowanych znaków pojedynczym znakiem. Wzorzec (\w)\1 wyrażenia regularnego pasuje do kolejnych wystąpień pojedynczego znaku i przypisuje pierwsze wystąpienie do pierwszej grupy przechwytywania. Wzorzec $1 zamiany zastępuje całe dopasowanie z pierwszą przechwyconą grupą.

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'

Uwagi

Wyszukiwanie dopasowań rozpoczyna się na początku input ciągu. Wyrażenie regularne to wzorzec zdefiniowany przez konstruktora dla bieżącego Regex obiektu. Jeśli count jest ujemna, zamiany są kontynuowane na końcu ciągu. Jeśli count przekroczy liczbę dopasowań, wszystkie dopasowania zostaną zastąpione.

Parametr replacement określa ciąg, który ma zastąpić pierwsze count dopasowania w elemencie input. replacement może składać się z dowolnej kombinacji tekstu literału i podstawień. Na przykład wzorzec a*${test}b zastępczy wstawia ciąg "a*", po którym następuje podciąg dopasowany przez test grupę przechwytywania, jeśli istnieje, a następnie ciąg "b". Znak * nie jest rozpoznawany jako metatyp w ramach wzorca zastępczego.

Uwaga

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, można użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy

Replace(String, String)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym ciągu wejściowym zastępuje wszystkie ciągi zgodne ze wzorcem wyrażenia regularnego określonym ciągiem zastępczym.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

replacement: String

Ciąg zastępujący.

Zwraca

String

Wyjątki

ArgumentNullException

input lub replacement ma wartość null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

W poniższym przykładzie zdefiniowano wyrażenie regularne , \s+które pasuje do co najmniej jednego znaku odstępu. Ciąg zastępczy " " zastępuje je pojedynczym znakiem spacji.

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.

W poniższym przykładzie zdefiniowano wyrażenie regularne, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, i wzorzec zastępczy , $2który usuwa wiodący lub końcowy symbol waluty z wartości liczbowej.

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'

Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.

Wzorce	Opis
`\p{Sc}`	Dopasuj symbol waluty. `{Sc}` oznacza dowolny znak, który jest elementem członkowskim kategorii Symbol Unicode, Waluta.
`\s?`	Dopasowuje zero lub jeden znak odstępu.
`(\p{Sc}\s?)?`	Dopasuj zero lub jedno wystąpienie kombinacji symbolu waluty, po którym następuje zero lub jeden znak odstępu. Jest to pierwsza grupa przechwytywania.
`\d+`	Dopasowanie do co najmniej jednej cyfry dziesiętnej.
`\.?`	Dopasuj zero lub jedno wystąpienie kropki (używane jako znak separatora dziesiętnego).
`((?<=\.)\d+)?`	Jeśli kropka jest poprzednim znakiem, dopasuj co najmniej jedną cyfrę dziesiętną. Ten wzorzec może być dopasowany do zera lub jednorazowego.
`(\d+\.?((?<=\.)\d+)?)`	Dopasuj wzorzec co najmniej jednej cyfry dziesiętnej, po której następuje opcjonalny kropka i dodatkowe cyfry dziesiętne. Jest to druga grupa przechwytywania. Wywołanie Replace(String, String) metody zastępuje całe dopasowanie wartością tej przechwyconej grupy.
`(?(1)\|\s?\p{Sc})?`	Jeśli istnieje pierwsza przechwycona grupa, dopasuj pusty ciąg. W przeciwnym razie dopasuj zero lub jeden znak odstępu, po którym następuje symbol waluty.

Uwagi

Wyszukiwanie dopasowań rozpoczyna się na początku input ciągu. Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktora dla bieżącego Regex obiektu.

Parametr replacement określa ciąg, który ma zastąpić każde dopasowanie w .input replacement może składać się z dowolnej kombinacji tekstu literału i podstawień. Na przykład wzorzec a*${test}b zastępczy wstawia ciąg "a*", po którym następuje podciąg dopasowany przez test grupę przechwytywania, jeśli istnieje, a następnie ciąg "b". Znak * nie jest rozpoznawany jako metatyp w ramach wzorca zastępczego.

Uwaga

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, można użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy

Replace(String, String, Int32, Int32)

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

Źródło:: Regex.Replace.cs

W określonym podciągu wejściowym zastępuje określoną maksymalną liczbę ciągów pasujących do wzorca wyrażenia regularnego określonym ciągiem zastępczym.

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

Parametry

input: String

Ciąg do wyszukania dopasowania.

replacement: String

Ciąg zastępujący.

count: Int32

Maksymalna liczba wystąpień zamiany.

startat: Int32

Pozycja znaku w ciągu wejściowym, w którym rozpoczyna się wyszukiwanie.

Zwraca

String

Wyjątki

ArgumentNullException

input lub replacement ma wartość null.

ArgumentOutOfRangeException

startat jest mniejsza niż zero lub większa niż długość input.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Przykłady

Poniższy przykład zawiera podwójne spacje, ale pierwszy wiersz ciągu. Definiuje wzorzec wyrażenia regularnego , ^.*$który pasuje do wiersza tekstu, wywołuje Match(String) metodę w celu dopasowania do pierwszego wiersza ciągu i używa Match.Index właściwości i Match.Count w celu określenia pozycji początkowej drugiego wiersza.

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.

Wzorzec ^.*$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorce	Opis
`^`	Dopasuj początek wiersza. (Zwróć uwagę, że Regex obiekt został utworzony przy użyciu RegexOptions.Multiline opcji . W przeciwnym razie ta klasa znaków będzie zgodna tylko z początkiem ciągu wejściowego).
`.*`	Dopasuj dowolny znak zero lub więcej razy.
`$`	Dopasuj koniec wiersza. (Zwróć uwagę, że Regex obiekt został utworzony przy użyciu RegexOptions.Multiline opcji . W przeciwnym razie ta klasa znaków będzie zgodna tylko z początkiem ciągu wejściowego).

Ciąg zastępczy (vbCrLf + "$&" w języku Visual Basic "\n$&" w języku C#) dodaje nowy wiersz przed dopasowanym ciągiem. Zwróć uwagę, że \n w przykładzie języka C# jest interpretowany jako znak nowego wiersza przez kompilator języka C#. Nie reprezentuje ucieczki znaku wyrażenia regularnego.

Uwagi

Wyszukiwanie dopasowań rozpoczyna się w input ciągu na pozycji określonej przez startat parametr . Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktora dla bieżącego Regex obiektu. Jeśli count jest ujemna, zamiany są kontynuowane na końcu ciągu. Jeśli count przekroczy liczbę dopasowań, wszystkie dopasowania zostaną zastąpione.

Aby uzyskać więcej informacji na temat startatprogramu , zobacz sekcję Uwagi w temacie Match(String, Int32).

Parametr replacement określa ciąg, który ma zastąpić każde dopasowanie w .input replacement może składać się z dowolnej kombinacji tekstu literału i podstawień. Na przykład wzorzec a*${test}b zastępczy wstawia ciąg "a*", po którym następuje podciąg dopasowany przez test grupę przechwytywania, jeśli istnieje, a następnie ciąg "b". Znak * nie jest rozpoznawany jako metatyp w ramach wzorca zastępczego.

Uwaga

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, można użyć Object.ReferenceEquals metody , aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

Dotyczy