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 zgodne z określonym wyrażeniem regularnym 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, które modyfikują zgodną 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 zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym. Dodatkowe parametry określają opcje, które modyfikują zgodną 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 zgodne z określonym wyrażeniem regularnym 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 wyszukiwania 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 jest 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 Regex.Replace(String, MatchEvaluator, Int32, Int32) jest przydatna 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 metody Regex.Matches(String, Int32) i przekazaniu pierwszych obiektów countMatch w zwróconej kolekcji MatchCollection do delegata evaluator.

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

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

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

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 wartość limitu czasu ustanowioną dla domeny aplikacji, w której jest tworzony obiekt Regex. Jeśli limit czasu nie jest zdefiniowany w wywołaniu konstruktora Regex lub we właściwościach domeny aplikacji lub jeśli wartość limitu czasu jest Regex.InfiniteMatchTimeout, nie jest zgłaszany wyjątek

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

Zobacz też

MatchEvaluator
podstawienia w wyrażeniach regularnych
język wyrażeń regularnych — krótki przewodnik

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 wyszukiwania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

replacement: String

Ciąg zastępczy.

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 dopasowana 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 jest 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 metody Replace(String, String, String), aby zastąpić nazwy maszyny lokalnej i dysków w ścieżce UNC ścieżką pliku lokalnego. Wyrażenie regularne używa właściwości Environment.MachineName do uwzględnienia nazwy komputera lokalnego, a metoda Environment.GetLogicalDrives zawiera nazwy 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.

Deseń	Opis
`\\\\`	Dopasuj dwa kolejne ukośniki odwrotne (`\`) . 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 zwróconego przez właściwość Environment.MachineName.
`(?:\.\w+)*`	Dopasuj kropkę (`.`) znak, 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 dolara literału (`$`) .

Wzorzec zastąpienia $1 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 obiektu Regex z określonym wzorcem wyrażenia regularnego i wywoływaniem metody wystąpienia Replace.

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 zastępczy a*${test}b wstawia ciąg "a*", po którym następuje podciąg zgodny z test grupą przechwytywania, jeśli istnieje, a następnie ciąg "b". Znak * nie jest rozpoznawany jako metacharakter w ramach wzorca zastępczego.

Nuta

Podstawianie 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 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 jest wywoływana metoda. Jeśli w właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu jest Regex.InfiniteMatchTimeout, nie jest zgłaszany żaden wyjątek.

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć metody Object.ReferenceEquals, 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ą zastępowania dopasowania wzorca jest Replace(String, String, String, RegexOptions, TimeSpan), co pozwala ustawić interwał 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 zwracanym przez delegata MatchEvaluator. Dodatkowe parametry określają opcje, które modyfikują zgodną 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 wyszukiwania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny dopasowany 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 jest null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitową wartości RegexOptions.

-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 do wyodrębnienia pojedynczych wyrazów z ciągu, a następnie użyto delegata MatchEvaluator w celu wywołania metody o nazwie WordScramble, która prześcignie poszczególne litery w słowie. W tym celu metoda WordScramble tworzy tablicę zawierającą znaki w dopasowaniu. Tworzy również tablicę równoległą wypełnianą losowymi liczbami zmiennoprzecinkowymi. Tablice są sortowane przez wywołanie metody Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), a posortowana tablica jest dostarczana jako argument konstruktora klasy String. Ten nowo utworzony ciąg jest następnie zwracany przez metodę WordScramble. Wzorzec wyrażenia regularnego \w+ pasuje do co najmniej jednego znaku słowa; aparat wyrażeń regularnych będzie nadal dodawać znaki do dopasowania, dopóki nie napotka znaku innego niż słowo, takiego jak znak odstępu. Wywołanie metody Replace(String, String, MatchEvaluator, RegexOptions) zawiera opcję RegexOptions.IgnorePatternWhitespace, dzięki czemu komentarz we wzorcu wyrażenia regularnego \w+ # Matches all the characters in a word. jest 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 Regex.Replace(String, String, MatchEvaluator, RegexOptions) jest przydatna 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 zamiany wyrażeń regularnych.
Jeśli ciąg zastępczy wynika z przetwarzania wykonywanego na dopasowanym ciągu.
Jeśli ciąg zastępczy wynika z przetwarzania warunkowego.

Metoda jest równoważna wywołaniu metody Regex.Matches(String, String, RegexOptions) i przekazaniu każdego obiektu Match w zwróconej kolekcji MatchCollection 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.

Jeśli określisz RightToLeft parametru options, 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 dopasowania wzorca powinna pró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, pojawia się na "przestań odpowiadać, gdy przetwarzają dane wejściowe, które zawierają zbliżone dopasowania. Aby uzyskać więcej informacji, zobacz Best Practices for Regular Expressions and Backtracking. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda zgłasza wyjątek RegexMatchTimeoutException. matchTimeout zastępuje 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ć metody Object.ReferenceEquals, 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ść, na przykład 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, aby powodować nadmierne wycofywanie 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 pasujące do określonego wyrażenia regularnego ciągiem zwracanym przez delegata MatchEvaluator. Określone opcje modyfikują zgodną 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 wyszukiwania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

evaluator: MatchEvaluator

Metoda niestandardowa, która sprawdza każde dopasowanie i zwraca oryginalny dopasowany 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 jest null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitową wartości RegexOptions.

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

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

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 metody Regex.Matches(String, String, RegexOptions) i przekazaniu każdego obiektu Match w zwróconej kolekcji MatchCollection 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ć metody Object.ReferenceEquals, 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 zgodne z określonym wyrażeniem regularnym określonym ciągiem zastępczym. Dodatkowe parametry określają opcje, które modyfikują zgodną 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 wyszukiwania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

replacement: String

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 replacement jest null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitową wartości RegexOptions.

-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 metody Replace(String, String, String, RegexOptions, TimeSpan), aby zastąpić nazwy maszyny lokalnej i dysków w ścieżce UNC ścieżką pliku lokalnego. Wyrażenie regularne używa właściwości Environment.MachineName do uwzględnienia nazwy komputera lokalnego i metody Environment.GetLogicalDrives do uwzględnienia nazw dysków logicznych. Wszystkie porównania ciągów wyrażeń regularnych są niewrażliwe na wielkość liter, a każda pojedyncza operacja zastępowania przekroczyła limit czasu, jeśli nie można odnaleźć dopasowania w 0,5 sekundy. 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.

Deseń	Opis
`\\\\`	Dopasuj dwa kolejne ukośniki odwrotne (`\`) . 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 właściwość Environment.MachineName.
`(?:\.\w+)*`	Dopasuj kropkę (`.`) znak, 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 dolara literału (`$`) .

Wzorzec zastąpienia $1 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 obiektu Regex z określonym wzorcem wyrażenia regularnego i wywoływaniem metody wystąpienia Replace.

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. Jeśli określisz RightToLeft parametru options, 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.

Nuta

Parametr matchTimeout określa, jak długo metoda dopasowania wzorca powinna próbować znaleźć dopasowanie przed upływem limitu czasu. Ustawienie interwału limitu czasu zapobiega wyrażeniom regularnym, 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. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda zgłasza wyjątek RegexMatchTimeoutException. matchTimeout zastępuje 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ć metody Object.ReferenceEquals, aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Uwagi dotyczące wywoływania

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, aby powodować nadmierne wycofywanie podczas przetwarzania niemal zgodnego.

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ą zgodną 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 wyszukiwania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

replacement: String

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 replacement jest null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitową wartości RegexOptions.

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 metody Replace(String, String, String, RegexOptions), aby zastąpić nazwy maszyny lokalnej i dysków w ścieżce UNC ścieżką pliku lokalnego. Wyrażenie regularne używa właściwości Environment.MachineName do uwzględnienia nazwy komputera lokalnego, a metoda Environment.GetLogicalDrives zawiera nazwy 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.

Deseń	Opis
`\\\\`	Dopasuj dwa kolejne ukośniki odwrotne (`\`) . 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 właściwość Environment.MachineName.
`(?:\.\w+)*`	Dopasuj kropkę (`.`) znak, 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 dolara literału (`$`) .

Wzorzec zastąpienia $1 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 obiektu Regex z określonym wzorcem wyrażenia regularnego i wywoływaniem metody wystąpienia Replace.

Nuta

Ponieważ metoda zwraca input niezmienione, jeśli nie ma dopasowania, możesz użyć metody Object.ReferenceEquals, 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 pasujące do określonego wyrażenia regularnego 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 wyszukiwania dopasowania.

evaluator: MatchEvaluator

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

Zwraca

String

Wyjątki

ArgumentNullException

input lub evaluator jest 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 Regex.Replace(String, MatchEvaluator) jest przydatna 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 metody Regex.Matches(String) i przekazaniu każdego obiektu Match w zwróconej kolekcji MatchCollection do delegata evaluator.

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

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ć metody Object.ReferenceEquals, aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

MatchEvaluator
podstawienia w wyrażeniach regularnych
język wyrażeń regularnych — krótki przewodnik

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 wyszukiwania 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.

Zwraca

String

Wyjątki

ArgumentNullException

input lub evaluator jest 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 regularnego \w*(ie|ei)\w* do dopasowywania wyrazów zawierających znaki "ie" lub "ei". Przekazuje pierwszą połowę pasujących wyrazów do metody ReverseLetter, która z kolei używa metody Replace(String, String, String, RegexOptions), aby odwrócić ciąg "i" i "e". Pozostałe wyrazy 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 regularne \w*(ie|ei)\w* jest zdefiniowane, jak pokazano w poniższej tabeli.

Deseń	Opis
`\w*`	Dopasuj zero lub więcej znaków wyrazów.
`(ie\|ei)`	Dopasuj wartość "ie" lub "ei".
`\w*`	Dopasuj zero lub więcej znaków wyrazów.

Wzorzec wyrażenia regularnego ([ie])([ie]) w metodzie ReverseLetter odpowiada pierwszemu "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 metody Replace(String, String, String) ze wzorcem zastępczym $2$1.

Uwagi

Metoda Regex.Replace(String, MatchEvaluator, Int32) jest przydatna 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 metody Regex.Matches(String) i przekazaniu pierwszych obiektów countMatch w zwróconej kolekcji MatchCollection do delegata evaluator.

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

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ć metody Object.ReferenceEquals, aby określić, czy metoda dokonała żadnych zamian w ciągu wejściowym.

Zobacz też

MatchEvaluator
podstawienia w wyrażeniach regularnych
język wyrażeń regularnych — krótki przewodnik

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 wyszukiwania dopasowania.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

evaluator: MatchEvaluator

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

Zwraca

String

Wyjątki

ArgumentException

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

ArgumentNullException

input, patternlub evaluator jest 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 Regex.Replace(String, String, MatchEvaluator) jest przydatna 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 metody Regex.Matches(String, String) i przekazaniu każdego obiektu Match w zwróconej kolekcji MatchCollection 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ć metody Object.ReferenceEquals, 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ą oceny i zastępowania dopasowania wzorca jest Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), która umożliwia ustawienie interwału 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 wyszukiwania dopasowania.

replacement: String

Ciąg zastępczy.

count: Int32

Maksymalna liczba wystąpień zamiany.

Zwraca

String

Wyjątki

ArgumentNullException

input lub replacement jest 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 wyrażenia regularnego (\w)\1 pasuje do kolejnych wystąpień pojedynczego znaku i przypisuje pierwsze wystąpienie do pierwszej grupy przechwytywania. Wzorzec zastępczy $1 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 ciągu input. Wyrażenie regularne to wzorzec zdefiniowany przez konstruktor dla bieżącego obiektu Regex. Jeśli count jest ujemna, zamiany będą kontynuowane na końcu ciągu. Jeśli count przekracza liczbę dopasowań, wszystkie dopasowania zostaną zastąpione.

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

Nuta

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

Zobacz też

język wyrażeń regularnych — krótki przewodnik
podstawienia w wyrażeniach regularnych

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 wyszukiwania dopasowania.

replacement: String

Ciąg zastępczy.

Zwraca

String

Wyjątki

ArgumentNullException

input lub replacement jest 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, $2, któ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, jak pokazano w poniższej tabeli.

Deseń	Opis
`\p{Sc}`	Dopasuj symbol waluty. `{Sc}` oznacza dowolny znak należący do kategorii Symbol Unicode, Waluta.
`\s?`	Dopasuj 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+`	Dopasuj co najmniej jedną cyfrę dziesiętną.
`\.?`	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żna dopasować 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 metody Replace(String, String) 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 ciągu input. Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktor dla bieżącego obiektu Regex.

Nuta

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

Zobacz też

język wyrażeń regularnych — krótki przewodnik
podstawienia w wyrażeniach regularnych

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 wyszukiwania dopasowania.

replacement: String

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

Wyjątki

ArgumentNullException

input lub replacement jest 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

W poniższym przykładzie podwójne spacje są wszystkie, ale pierwszy wiersz ciągu. Definiuje wzorzec wyrażenia regularnego, ^.*$, który pasuje do wiersza tekstu, wywołuje metodę Match(String), aby dopasować pierwszy wiersz ciągu i używa właściwości Match.Index 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.

Deseń	Opis
`^`	Dopasuj początek wiersza. (Zwróć uwagę, że obiekt Regex został utworzony przy użyciu opcji RegexOptions.Multiline; w przeciwnym razie ta klasa znaków będzie pasowała tylko do początku ciągu wejściowego).
`.*`	Dopasuj dowolny znak zero lub więcej razy.
`$`	Dopasuj koniec wiersza. (Zwróć uwagę, że obiekt Regex został utworzony przy użyciu opcji RegexOptions.Multiline; w przeciwnym razie ta klasa znaków będzie pasowała tylko do początku 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. Należy pamiętać, ż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 ciągu input w pozycji określonej przez parametr startat. Wyrażenie regularne jest wzorcem zdefiniowanym przez konstruktor dla bieżącego obiektu Regex. Jeśli count jest ujemna, zamiany będą kontynuowane na końcu ciągu. Jeśli count przekracza liczbę dopasowań, wszystkie dopasowania zostaną zastąpione.

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

Nuta

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

Zobacz też

podstawienia w wyrażeniach regularnych
język wyrażeń regularnych — krótki przewodnik

Dotyczy

Udostępnij za pośrednictwem

Regex.Replace Metoda

Definicja

Przeciążenia

Replace(String, MatchEvaluator, Int32, Int32)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

Replace(String, String, String)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

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

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Replace(String, String, MatchEvaluator, RegexOptions)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

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

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Replace(String, String, String, RegexOptions)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Replace(String, MatchEvaluator)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Replace(String, MatchEvaluator, Int32)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Replace(String, String, MatchEvaluator)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy