Regex.Replace Metoda

Reference

Definice

Obor názvů:: System.Text.RegularExpressions

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

V zadaném vstupním řetězci nahradí řetězce, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

Přetížení

Replace(String, MatchEvaluator, Int32, Int32)	V zadaném vstupním podřetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, řetězcem vráceným delegátem MatchEvaluator .
Replace(String, String, String)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem.
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)	V zadaném vstupním řetězci nahradí všechny podřetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator . Další parametry určují možnosti, které upraví operaci párování, a interval časového limitu, pokud není nalezena žádná shoda.
Replace(String, String, MatchEvaluator, RegexOptions)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator . Zadané možnosti upraví odpovídající operaci.
Replace(String, String, String, RegexOptions, TimeSpan)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem. Další parametry určují možnosti, které upraví operaci párování, a interval časového limitu, pokud není nalezena žádná shoda.
Replace(String, String, String, RegexOptions)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem. Zadané možnosti upraví odpovídající operaci.
Replace(String, MatchEvaluator)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator .
Replace(String, MatchEvaluator, Int32)	V zadaném vstupním řetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, řetězcem vráceným delegátem MatchEvaluator .
Replace(String, String, MatchEvaluator)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator .
Replace(String, String, Int32)	V zadaném vstupním řetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.
Replace(String, String)	V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.
Replace(String, String, Int32, Int32)	V zadaném vstupním podřetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

Replace(String, MatchEvaluator, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním podřetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, řetězcem vráceným delegátem 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

Řetězec, který má vyhledat shodu.

evaluator: MatchEvaluator

Vlastní metoda, která zkoumá každou shodu a vrátí buď původní odpovídající řetězec, nebo náhradní řetězec.

count: Int32

Maximální počet výskytů nahrazení.

startat: Int32

Pozice znaku ve vstupním řetězci, kde začíná hledání.

Návraty

String

Nový řetězec, který je identický se vstupním řetězcem, s tím rozdílem, že každý odpovídající řetězec nahradí náhradní řetězec. Pokud se vzor regulárního výrazu v aktuální instanci neshoduje, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentNullException

input nebo evaluator je null.

ArgumentOutOfRangeException

startatje menší než nula nebo větší než délka .input

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metoda Regex.Replace(String, MatchEvaluator, Int32, Int32) je užitečná pro nahrazení shody regulárního výrazu, pokud platí některá z následujících podmínek:

Náhradní řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.
Náhradní řetězec je výsledkem zpracování provedeného u odpovídajícího řetězce.
Náhradní řetězec je výsledkem podmíněného zpracování.

Metoda je ekvivalentní volání Regex.Matches(String, Int32) metody a předání prvních countMatch objektů ve vrácené MatchCollection kolekci delegátu evaluator .

Další podrobnosti o startatnástroji najdete v části Poznámky v souboru Match(String, Int32).

Regulární výraz je vzor definovaný konstruktorem pro aktuální Regex objekt.

Parametr evaluator je delegátem pro vlastní metodu, kterou definujete a která zkoumá každou shodu. Vlastní metoda musí mít následující podpis, aby odpovídal delegátu MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace nahrazení překročí časový limit určený konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud při volání konstruktoru nenastavíte časový limit, vyvolá se výjimka, pokud operace překročí jakoukoli hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Vzhledem k tomu, že metoda vrátí input beze změny, pokud neexistuje žádná shoda, můžete použít metodu Object.ReferenceEquals k určení, zda metoda provedla nějaké nahrazení vstupního řetězce.

Viz také

Platí pro

Replace(String, String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem.

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

Řetězec, který má vyhledat shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

replacement: String

Náhradní řetězec

Návraty

String

Nový řetězec, který je shodný se vstupním řetězcem, s tím rozdílem, že náhradní řetězec nahrazuje každý odpovídající řetězec. Pokud pattern se v aktuální instanci neshoduje, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentException

Došlo k chybě parsování regulárního výrazu.

ArgumentNullException

input, patternnebo replacement je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad definuje regulární výraz , \s+který odpovídá jednomu nebo více prázdným znakům. Náhradní řetězec "" je nahradí jedním znakem mezery.

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.

Následující příklad používá metodu Replace(String, String, String) k nahrazení místních počítačů a jednotek v cestě UNC místní cestou k souboru. Regulární výraz používá Environment.MachineName vlastnost k zahrnutí názvu místního počítače a metodu Environment.GetLogicalDrives pro zahrnutí názvů logických jednotek. Pokud chcete příklad úspěšně spustit, měli byste řetězec literálu "MyMachine" nahradit názvem místního počítače.

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

Vzor regulárního výrazu je definován následujícím výrazem:

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

Následující tabulka ukazuje, jak se vzor regulárního výrazu interpretuje.

Vzor	Description
`\\\\`	Porovná dva po sobě jdoucí znaky zpětného lomítka (`\`). Vzhledem k tomu, že znak zpětného lomítka je interpretován jako řídicí znak, musí být každé zpětné lomítko uchváceno s jiným zpětným lomítkem.
`(?i:" + Environment.MachineName + ")`	Proveďte shodu řetězce, který je vrácen vlastností, nerozlišují malá a velká písmena Environment.MachineName .
`(?:\.\w+)*`	Porovná znak tečky (`.`), za nímž následuje jeden nebo více znaků slova. K této shodě může dojít nula nebo vícekrát. Odpovídající dílčí výraz se nezachytí.
`\\`	Porovná znak zpětného lomítka (`\`).
`((?i:[" + driveNames + "]))`	Proveďte shodu třídy znaků, která se skládá z jednotlivých písmen jednotek, bez rozlišování velkých a malých písmen. Tato shoda je prvním zachyceným dílčím výrazem.
`\$`	Porovná znak literálového znaku dolaru (`$`).

Model nahrazení $1 nahradí celou shodu prvním zachyceným dílčím výrazem. To znamená, že nahradí počítač UNC a název jednotky písmenem jednotky.

Poznámky

Statické Replace metody jsou ekvivalentní k vytvoření objektu Regex se zadaným vzorem regulárního výrazu a volání metody Replaceinstance .

Parametr replacement určuje řetězec, který má nahradit každou shodu v input. replacement může se skládat z libovolné kombinace literálového textu a nahrazení. Vzor nahrazení a*${test}b například vloží řetězec "a*" následovaný podřetězcem test , který odpovídá zachytávcené skupině, pokud existuje, následovaný řetězcem "b". Znak * není rozpoznán jako metaznač v rámci vzoru nahrazení.

Poznámka

Nahrazení jsou jedinými prvky jazyka regulárních výrazů, které jsou rozpoznány ve vzoru nahrazení. Všechny ostatní prvky jazyka regulárních výrazů, včetně řídicích znaků, jsou povoleny pouze ve vzorech regulárních výrazů a nejsou rozpoznány v náhradních vzorech.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace nahrazení překročí interval časového limitu zadaného pro doménu aplikace, ve které je metoda volána. Pokud není ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Vzhledem k tomu, že metoda vrací input beze změny, pokud neexistuje žádná shoda, můžete pomocí Object.ReferenceEquals metody určit, zda metoda provedla nějaké nahrazení vstupního řetězce.

Poznámky pro volající

Časový limit této metody vyprší po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána. Pokud hodnota časového limitu nebyla definována pro doménu aplikace, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučená statická metoda pro nahrazení shody vzorů je Replace(String, String, String, RegexOptions, TimeSpan), která umožňuje nastavit interval časového limitu.

Viz také

Platí pro

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny podřetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator . Další parametry určují možnosti, které upravují odpovídající operaci a časový limit, pokud se nenajde žádná shoda.

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

Řetězec, který hledá shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

evaluator: MatchEvaluator

Vlastní metoda, která prověřuje každou shodu a vrátí buď původní odpovídající řetězec, nebo náhradní řetězec.

options: RegexOptions

Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.

matchTimeout: TimeSpan

Časový limit nebo InfiniteMatchTimeout označující, že by nemělo dojít k vypršení časového limitu metody.

Návraty

String

Výjimky

ArgumentException

Při analýze regulárního výrazu došlo k chybě.

ArgumentNullException

input, patternnebo evaluator je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

-nebo-

matchTimeout je záporná, nulová nebo větší než přibližně 24 dnů.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad používá regulární výraz k extrahování jednotlivých slov z řetězce a potom používá MatchEvaluator delegáta k volání metody s názvem WordScramble , která zakóduje jednotlivá písmena ve slově. Za tímto účelem WordScramble metoda vytvoří pole, které obsahuje znaky v shodě. Vytvoří také paralelní pole, které naplní náhodnými čísly s plovoucí desetinnou čárkou. Pole jsou seřazena voláním Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metody a seřazené pole je poskytováno jako argument konstruktoru String třídy. Tento nově vytvořený řetězec je pak vrácen metodou .WordScramble Vzor \w+ regulárního výrazu odpovídá jednomu nebo více znakům slova. Modul regulárních výrazů bude nadále přidávat znaky do shody, dokud nenarazí na jiný než slovní znak, například prázdný znak. Volání Replace(String, String, MatchEvaluator, RegexOptions) metody zahrnuje RegexOptions.IgnorePatternWhitespace možnost , aby byl komentář ve vzorci \w+ # Matches all the characters in a word. regulárního výrazu ignorován modulem regulárních výrazů.

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

Poznámky

Metoda Regex.Replace(String, String, MatchEvaluator, RegexOptions) je užitečná k nahrazení shody regulárního výrazu, pokud platí některá z následujících podmínek:

Pokud nahrazovací řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.
Pokud je náhradní řetězec výsledkem nějakého zpracování provedeného u odpovídajícího řetězce.
Pokud je náhradní řetězec výsledkem podmíněného zpracování.

Metoda je ekvivalentní volání Regex.Matches(String, String, RegexOptions) metody a předání každého Match objektu ve vrácené MatchCollection kolekci delegátu evaluator .

Parametr evaluator je delegátem pro vlastní metodu, kterou definujete a která zkoumá každou shodu. Vlastní metoda musí mít následující podpis, aby odpovídal delegátu MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Pokud pro options parametr zadáteRightToLeft, hledání shod začne na konci vstupního řetězce a přesune se doleva. V opačném případě hledání začne na začátku vstupního řetězce a přesune se doprava.

Parametr matchTimeout určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit najít shodu, než vyprší časový limit. Nastavení intervalu časového limitu zabrání tomu, aby regulární výrazy, které jsou závislé na nadměrném navracení, přestaly reagovat, když zpracovávají vstup, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a zpětné navracení. Pokud se v daném časovém intervalu nenajde žádná shoda, metoda vyvolá RegexMatchTimeoutException výjimku. matchTimeout přepíše výchozí hodnotu časového limitu definovanou pro doménu aplikace, ve které se metoda spouští.

Poznámky pro volající

Doporučujeme nastavit parametr na matchTimeout odpovídající hodnotu, například dvě sekundy. Pokud časové limity zakážete zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí o něco lepší výkon. Časové limity byste ale měli zakázat pouze za následujících podmínek:

Když je vstup zpracovaný regulárním výrazem odvozen ze známého a důvěryhodného zdroje nebo se skládá ze statického textu. Tím se vyloučí text, který uživatelé zadali dynamicky.
Když byl vzor regulárního výrazu důkladně otestován, aby se zajistilo, že efektivně zpracovává shody, neshody a blízké shody.
Když vzor regulárního výrazu neobsahuje žádné elementy jazyka, o kterých je známo, že způsobují nadměrné navracení při zpracování téměř shody.

Viz také

Platí pro

Replace(String, String, MatchEvaluator, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem MatchEvaluator . Zadané možnosti upraví odpovídající operaci.

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

Řetězec, který hledá shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

evaluator: MatchEvaluator

Vlastní metoda, která prověřuje každou shodu a vrátí buď původní odpovídající řetězec, nebo náhradní řetězec.

options: RegexOptions

Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.

Návraty

String

Nový řetězec, který je shodný se vstupním řetězcem, s tím rozdílem, že každý odpovídající řetězec nahradí náhradní řetězec. Pokud pattern se v aktuální instanci neshoduje, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentException

Při analýze regulárního výrazu došlo k chybě.

ArgumentNullException

input, patternnebo evaluator je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

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

Poznámky

Metoda Regex.Replace(String, String, MatchEvaluator, RegexOptions) je užitečná k nahrazení shody regulárního výrazu v, pokud platí některá z následujících podmínek:

Nahrazovací řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.
Náhradní řetězec je výsledkem zpracování odpovídajícího řetězce.
Náhradní řetězec je výsledkem podmíněného zpracování.

Metoda je ekvivalentní volání Regex.Matches(String, String, RegexOptions) metody a předání každého Match objektu ve vrácené MatchCollection kolekci delegátu evaluator .

Parametr evaluator je delegátem pro vlastní metodu, kterou definujete a která zkoumá každou shodu. Vlastní metoda musí mít následující podpis, aby odpovídal delegátu MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Viz také

Platí pro

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem. Další parametry určují možnosti, které upraví operaci párování, a interval časového limitu, pokud není nalezena žádná shoda.

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

Řetězec, který má vyhledat shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

replacement: String

Náhradní řetězec

options: RegexOptions

Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.

matchTimeout: TimeSpan

Interval časového limitu nebo InfiniteMatchTimeout označující, že by nemělo dojít k vypršení časového limitu metody.

Návraty

String

Nový řetězec, který je identický se vstupním řetězcem, s tím rozdílem, že náhradní řetězec nahrazuje každý odpovídající řetězec. Pokud pattern není v aktuální instanci shoda, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentException

Došlo k chybě parsování regulárního výrazu.

ArgumentNullException

input, patternnebo replacement je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

-nebo-

matchTimeout je záporná, nulová nebo větší než přibližně 24 dnů.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad používá metodu Replace(String, String, String, RegexOptions, TimeSpan) k nahrazení místních počítačů a jednotek v cestě UNC místní cestou k souboru. Regulární výraz používá Environment.MachineName vlastnost k zahrnutí názvu místního počítače a Environment.GetLogicalDrives metody pro zahrnutí názvů logických jednotek. Všechna porovnání řetězců regulárních výrazů nerozlišují malá a velká písmena a pokud nelze najít shodu za 0,5 sekundy, vyprší časový limit každé operace nahrazení. Pokud chcete příklad úspěšně spustit, měli byste řetězec literálu "MyMachine" nahradit názvem místního počítače.

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

Vzor regulárního výrazu je definován následujícím výrazem:

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

Následující tabulka ukazuje, jak se vzor regulárního výrazu interpretuje.

Vzor	Description
`\\\\`	Porovná dva po sobě jdoucí znaky zpětného lomítka (`\`). Vzhledem k tomu, že znak zpětného lomítka je interpretován jako řídicí znak, musí být každé zpětné lomítko uchváceno s jiným zpětným lomítkem.
`+ Environment.MachineName +`	Porovná řetězec vrácený Environment.MachineName vlastností.
`(?:\.\w+)*`	Porovná znak tečky (`.`), za nímž následuje jeden nebo více znaků slova. K této shodě může dojít nula nebo vícekrát. Odpovídající dílčí výraz se nezachytí.
`\\`	Porovná znak zpětného lomítka (`\`).
`([" + driveNames + "])`	Porovná třídu znaků, která se skládá z jednotlivých písmen jednotek. Tato shoda je prvním zachyceným dílčím výrazem.
`\$`	Porovná znak literálového znaku dolaru (`$`).

Model nahrazení $1 nahradí celou shodu prvním zachyceným dílčím výrazem. To znamená, že nahradí počítač UNC a název jednotky písmenem jednotky.

Poznámky

Statické Replace metody jsou ekvivalentní k vytvoření objektu Regex se zadaným vzorem regulárního výrazu a volání metody Replaceinstance .

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a Jazyk regulárních výrazů – stručná referenční příručka. Pokud pro options parametr zadáteRightToLeft, začne hledání shod na konci vstupního řetězce a přesune se doleva. V opačném případě hledání začíná na začátku vstupního řetězce a přesune se doprava.

Parametr replacement určuje řetězec, který má nahradit každou shodu v input. replacement může se skládat z libovolné kombinace literálového textu a nahrazení. Vzor nahrazení a*${test}b například vloží řetězec "a*" následovaný podřetězcem, který je spárován test se skupinou zachycení, pokud existuje, následovaný řetězcem "b". Znak * není rozpoznán jako metacharakter v rámci vzoru nahrazení.

Poznámka

Parametr matchTimeout určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit najít shodu, než vyprší časový limit. Nastavení intervalu časového limitu zabrání tomu, aby regulární výrazy, které jsou závislé na nadměrném navracení, přestaly reagovat, když zpracovávají vstup, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a backtracking. Pokud se v daném časovém intervalu nenajde žádná shoda, metoda vyvolá RegexMatchTimeoutException výjimku. matchTimeout přepíše všechny výchozí hodnoty časového limitu definované pro doménu aplikace, ve které se metoda spouští.

Poznámky pro volající

Doporučujeme nastavit parametr na matchTimeout odpovídající hodnotu, například dvě sekundy. Pokud zakážete vypršení časových limitů zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí o něco lepší výkon. Vypršení časových limitů byste ale měli zakázat pouze za následujících podmínek:

Když je vstup zpracovaný regulárním výrazem odvozen ze známého a důvěryhodného zdroje nebo se skládá ze statického textu. Tím se vyloučí text, který uživatelé zadává dynamicky.
Když byl vzor regulárního výrazu důkladně otestován, aby se zajistilo, že efektivně zpracovává shody, neshody a blízké shody.
Když vzor regulárního výrazu neobsahuje žádné elementy jazyka, o kterých je známo, že způsobují nadměrné navracení při zpracování téměř shody.

Viz také

Platí pro

Replace(String, String, String, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, zadaným náhradním řetězcem. Zadané možnosti upraví odpovídající operaci.

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

Řetězec, který má vyhledat shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

replacement: String

Náhradní řetězec

options: RegexOptions

Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.

Návraty

String

Výjimky

ArgumentException

Došlo k chybě parsování regulárního výrazu.

ArgumentNullException

input, patternnebo replacement je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad používá metodu Replace(String, String, String, RegexOptions) k nahrazení místních počítačů a jednotek v cestě UNC místní cestou k souboru. Regulární výraz používá Environment.MachineName vlastnost k zahrnutí názvu místního počítače a metodu Environment.GetLogicalDrives pro zahrnutí názvů logických jednotek. Všechna porovnání řetězců regulárních výrazů nerozlišují velká a malá písmena. Pokud chcete příklad úspěšně spustit, měli byste řetězec literálu "MyMachine" nahradit názvem místního počítače.

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

Vzor regulárního výrazu je definován následujícím výrazem:

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

Následující tabulka ukazuje, jak se vzor regulárního výrazu interpretuje.

Vzor	Description
`\\\\`	Porovná dva po sobě jdoucí znaky zpětného lomítka (`\`). Vzhledem k tomu, že znak zpětného lomítka je interpretován jako řídicí znak, musí být každé zpětné lomítko uchváceno s jiným zpětným lomítkem.
`+ Environment.MachineName +`	Porovná řetězec vrácený Environment.MachineName vlastností.
`(?:\.\w+)*`	Porovná znak tečky (`.`), za nímž následuje jeden nebo více znaků slova. K této shodě může dojít nula nebo vícekrát. Odpovídající dílčí výraz se nezachytí.
`\\`	Porovná znak zpětného lomítka (`\`).
`([" + driveNames + "])`	Porovná třídu znaků, která se skládá z jednotlivých písmen jednotek. Tato shoda je prvním zachyceným dílčím výrazem.
`\$`	Porovná znak literálového znaku dolaru (`$`).

Model nahrazení $1 nahradí celou shodu prvním zachyceným dílčím výrazem. To znamená, že nahradí počítač UNC a název jednotky písmenem jednotky.

Poznámky

Statické Replace metody jsou ekvivalentní k vytvoření objektu Regex se zadaným vzorem regulárního výrazu a volání metody Replaceinstance .

Parametr replacement určuje řetězec, který má nahradit každou shodu v input. replacement může se skládat z libovolné kombinace literálového textu a nahrazení. Vzor nahrazení a*${test}b například vloží řetězec "a*" následovaný podřetězcem, který je spárován test se skupinou zachycení, pokud existuje, následovaný řetězcem "b". Znak * není rozpoznán jako metacharakter v rámci vzoru nahrazení.

Poznámka

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace nahrazení překročí časový limit zadaný pro doménu aplikace, ve které je volána metoda. Pokud ve vlastnostech domény aplikace není definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Poznámky pro volající

Viz také

Platí pro

Replace(String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem 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

Řetězec, který má vyhledat shodu.

evaluator: MatchEvaluator

Vlastní metoda, která zkoumá každou shodu a vrátí buď původní odpovídající řetězec, nebo náhradní řetězec.

Návraty

String

Výjimky

ArgumentNullException

input nebo evaluator je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad kódu zobrazí původní řetězec, porovná každé slovo v původním řetězci, převede první znak každé shody na velká písmena a pak zobrazí převedený řetězec.

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]

Poznámky

Metoda Regex.Replace(String, MatchEvaluator) je užitečná pro nahrazení shody regulárního výrazu, pokud platí některá z následujících podmínek:

Náhradní řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.
Náhradní řetězec je výsledkem zpracování provedeného u odpovídajícího řetězce.
Náhradní řetězec je výsledkem podmíněného zpracování.

Metoda je ekvivalentní volání Regex.Matches(String) metody a předání každého Match objektu ve vrácené MatchCollection kolekci delegátu evaluator .

Regulární výraz je vzor definovaný konstruktorem pro aktuální Regex objekt.

Parametr evaluator je delegátem pro vlastní metodu, kterou definujete a která zkoumá každou shodu. Vlastní metoda musí mít následující podpis, aby odpovídal delegátu MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Viz také

Platí pro

Replace(String, MatchEvaluator, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, řetězcem vráceným delegátem 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

Řetězec, který má vyhledat shodu.

evaluator: MatchEvaluator

Vlastní metoda, která zkoumá každou shodu a vrátí buď původní odpovídající řetězec, nebo náhradní řetězec.

count: Int32

Maximální počet výskytů nahrazení.

Návraty

String

Výjimky

ArgumentNullException

input nebo evaluator je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad používá regulární výraz k úmyslu chybně napsat polovinu slov v seznamu. Používá regulární výraz \w*(ie|ei)\w* ke shodě slov, která obsahují znaky "ie" nebo "ei". Předá první polovinu odpovídajících slov ReverseLetter metodě, která pak používá metodu Replace(String, String, String, RegexOptions) k obrácení slov "i" a "e" ve shodném řetězci. Zbývající slova zůstanou beze změny.

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

Regulární výraz \w*(ie|ei)\w* je definován tak, jak je znázorněno v následující tabulce.

Vzor	Description
`\w*`	Porovná žádný nebo více znaků slova.
`(ie\|ei)`	Porovná buď "ie", nebo "ei".
`\w*`	Porovná žádný nebo více znaků slova.

Vzor ([ie])([ie]) regulárního výrazu ReverseLetter v metodě odpovídá prvnímu "i" nebo "e" v záphthongu "ie" nebo "ei" a přiřadí písmeno první zachytácí skupině. Odpovídá druhému písmenu "i" nebo "e" a přiřadí písmeno druhé skupině zachycení. Dva znaky jsou pak obráceny voláním Replace(String, String, String) metody s náhradním vzorem $2$1.

Poznámky

Metoda Regex.Replace(String, MatchEvaluator, Int32) je užitečná pro nahrazení shody regulárního výrazu, pokud platí některá z následujících podmínek:

Náhradní řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.
Náhradní řetězec je výsledkem zpracování provedeného u odpovídajícího řetězce.
Náhradní řetězec je výsledkem podmíněného zpracování.

Metoda je ekvivalentní volání Regex.Matches(String) metody a předání prvních countMatch objektů ve vrácené MatchCollection kolekci delegátu evaluator .

Regulární výraz je vzor definovaný konstruktorem pro aktuální Regex objekt.

Parametr evaluator je delegátem pro vlastní metodu, kterou definujete a která zkoumá každou shodu. Vlastní metoda musí mít následující podpis, aby odpovídal delegátu MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Viz také

Platí pro

Replace(String, String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají zadanému regulárnímu výrazu, řetězcem vráceným delegátem 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

Řetězec, který má vyhledat shodu.

pattern: String

Vzor regulárního výrazu, který se má shodovat.

evaluator: MatchEvaluator

Vlastní metoda, která zkoumá každou shodu a vrátí buď původní odpovídající řetězec, nebo náhradní řetězec.

Návraty

String

Nový řetězec, který je identický se vstupním řetězcem, s tím rozdílem, že každý odpovídající řetězec nahradí náhradní řetězec. Pokud pattern není v aktuální instanci shoda, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentException

Došlo k chybě parsování regulárního výrazu.

ArgumentNullException

input, patternnebo evaluator je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad používá regulární výraz k extrahování jednotlivých slov z řetězce a potom použije MatchEvaluator delegáta k volání metody s názvem WordScramble , která zakóduje jednotlivá písmena ve slově. Za tímto účelem WordScramble metoda vytvoří pole, které obsahuje znaky v shodě. Vytvoří také paralelní pole, které naplní náhodnými čísly s plovoucí desetinnou čárkou. Pole jsou seřazena voláním Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metody a seřazené pole je poskytnuto jako argument konstruktoru String třídy. Tento nově vytvořený řetězec je pak vrácen metodou WordScramble . Vzor \w+ regulárního výrazu odpovídá jednomu nebo více znakům slova. Modul regulárních výrazů bude dál přidávat znaky do shody, dokud nenarazí na znak jiného slova, například prázdný znak.

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

Poznámky

Metoda Regex.Replace(String, String, MatchEvaluator) je užitečná pro nahrazení shody regulárního výrazu, pokud platí některá z následujících podmínek:

Náhradní řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.
Náhradní řetězec je výsledkem zpracování provedeného u odpovídajícího řetězce.
Náhradní řetězec je výsledkem podmíněného zpracování.

Metoda je ekvivalentní volání Regex.Matches(String, String) metody a předání každého Match objektu ve vrácené MatchCollection kolekci delegátu evaluator .

Parametr evaluator je delegátem pro vlastní metodu, kterou definujete a která zkoumá každou shodu. Vlastní metoda musí mít následující podpis, aby odpovídal delegátu MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Poznámky pro volající

Časový limit této metody vyprší po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána. Pokud hodnota časového limitu nebyla definována pro doménu aplikace, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučená statická metoda pro vyhodnocení a nahrazení shody vzorů je Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), která umožňuje nastavit interval časového limitu.

Viz také

Platí pro

Replace(String, String, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

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

Řetězec, který má vyhledat shodu.

replacement: String

Náhradní řetězec

count: Int32

Maximální počet výskytů nahrazení.

Návraty

String

Nový řetězec, který je identický se vstupním řetězcem, s tím rozdílem, že náhradní řetězec nahrazuje každý odpovídající řetězec. Pokud se vzor regulárního výrazu v aktuální instanci neshoduje, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentNullException

input nebo replacement je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad nahradí prvních pět výskytů duplicitních znaků jedním znakem. Vzor (\w)\1 regulárního výrazu odpovídá po sobě jdoucím výskytům jednoho znaku a přiřadí první výskyt první zachytávající skupině. Model nahrazení $1 nahradí celou shodu první zachycenou skupinou.

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'

Poznámky

Hledání shod začíná na začátku input řetězce. Regulární výraz je vzor, který je definován konstruktorem pro aktuální Regex objekt. Pokud count je negativní, nahrazení pokračuje až na konec řetězce. Pokud count počet shod překročí, nahradí se všechny shody.

Parametr replacement určuje řetězec, který má nahradit první count shody v inputsouboru . replacement může se skládat z libovolné kombinace literálového textu a nahrazení. Vzor nahrazení a*${test}b například vloží řetězec "a*" následovaný podřetězcem, který je spárován test se skupinou zachycení, pokud existuje, následovaný řetězcem "b". Znak * není rozpoznán jako metacharakter v rámci vzoru nahrazení.

Poznámka

Viz také

Platí pro

Replace(String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním řetězci nahradí všechny řetězce, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

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

Řetězec, který má vyhledat shodu.

replacement: String

Náhradní řetězec

Návraty

String

Výjimky

ArgumentNullException

input nebo replacement je null.

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad definuje regulární výraz , \s+který odpovídá jednomu nebo více prázdným znakům. Náhradní řetězec "" je nahradí jedním znakem mezery.

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.

Následující příklad definuje regulární výraz (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?a vzor nahrazení , $2který z číselné hodnoty odebere počáteční nebo koncový symbol měny.

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'

Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.

Vzor	Description
`\p{Sc}`	Porovná symbol měny. `{Sc}` označuje jakýkoli znak, který je členem kategorie Symbol Unicode, Měna.
`\s?`	Porovná žádný nebo jeden prázdný znak.
`(\p{Sc}\s?)?`	Porovná nula nebo jeden výskyt kombinace symbolu měny následovaný nulovým nebo jedním prázdným znakem. Toto je první zachytávající skupina.
`\d+`	Porovná jednu nebo více desítkových číslic.
`\.?`	Porovná nula nebo jeden výskyt tečky (používá se jako oddělovač desetinných míst).
`((?<=\.)\d+)?`	Pokud je tečka předchozím znakem, porovná jednu nebo více desetinných číslic. Tento vzor může být spárován nula nebo jednorázově.
`(\d+\.?((?<=\.)\d+)?)`	Porovná vzor jedné nebo více desetinných číslic následovaných volitelnou tečkou a dalšími desetinnými číslicemi. Toto je druhá zachytávající skupina. Volání Replace(String, String) metody nahradí celou shodu hodnotou této zachycené skupiny.
`(?(1)\|\s?\p{Sc})?`	Pokud existuje první zachycená skupina, spárujte prázdný řetězec. V opačném případě porovnáte nula nebo jeden prázdný znak následovaný symbolem měny.

Poznámky

Hledání shod začíná na začátku input řetězce. Regulární výraz je vzor definovaný konstruktorem pro aktuální Regex objekt.

Parametr replacement určuje řetězec, který má nahradit každou shodu v input. replacement může se skládat z libovolné kombinace literálového textu a nahrazení. Vzor nahrazení a*${test}b například vloží řetězec "a*" následovaný podřetězcem, který je spárován test se skupinou zachycení, pokud existuje, následovaný řetězcem "b". Znak * není rozpoznán jako metacharakter v rámci vzoru nahrazení.

Poznámka

Viz také

Platí pro

Replace(String, String, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

V zadaném vstupním podřetězci nahradí zadaný maximální počet řetězců, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem.

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

Řetězec, který má vyhledat shodu.

replacement: String

Náhradní řetězec

count: Int32

Maximální počet výskytů nahrazení

startat: Int32

Pozice znaku ve vstupním řetězci, kde začíná hledání.

Návraty

String

Nový řetězec, který je shodný se vstupním řetězcem, s tím rozdílem, že náhradní řetězec nahrazuje každý odpovídající řetězec. Pokud se vzor regulárního výrazu neshoduje v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

ArgumentNullException

input nebo replacement je null.

ArgumentOutOfRangeException

startatje menší než nula nebo větší než délka .input

RegexMatchTimeoutException

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Příklady

Následující příklad dvakrát mezery všechny kromě prvního řádku řetězce. Definuje vzor regulárního výrazu , ^.*$který odpovídá řádku textu, volá metodu Match(String) tak, aby odpovídala prvnímu řádku řetězce, a používá Match.Index vlastnosti a Match.Count k určení počáteční pozice druhého řádku.

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.

Vzor ^.*$ regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.

Vzor	Description
`^`	Porovná začátek řádku. (Všimněte si, že instance objektu Regex byla vytvořena pomocí RegexOptions.Multiline možnosti; jinak by tato třída znaků odpovídala pouze začátku vstupního řetězce.)
`.*`	Porovná libovolný znak nula nebo vícekrát.
`$`	Porovná konec řádku. (Všimněte si, že instance objektu Regex byla vytvořena pomocí RegexOptions.Multiline možnosti; jinak by tato třída znaků odpovídala pouze začátku vstupního řetězce.)

Náhradní řetězec (vbCrLf + "$&" v jazyce Visual Basic v "\n$&" jazyce C#) přidá nový řádek před odpovídající řetězec. Všimněte si, že \n kompilátor jazyka C# v příkladu jazyka C# interpretuje jako znak nového řádku; nepředstavuje řídicí znak regulárního výrazu.

Poznámky

Hledání shody začíná v řetězci input na pozici určené parametrem startat . Regulární výraz je vzor definovaný konstruktorem pro aktuální Regex objekt. Pokud count je záporná, nahrazení pokračuje až na konec řetězce. Pokud count překročí počet shod, nahradí se všechny shody.

Další podrobnosti o startatnástroji najdete v části Poznámky v souboru Match(String, Int32).

Parametr replacement určuje řetězec, který má nahradit každou shodu v input. replacement může se skládat z jakékoli kombinace literálového textu a substitucí. Vzor nahrazení a*${test}b například vloží řetězec "a*" následovaný podřetězcem test , který odpovídá zachytávcené skupině, pokud existuje, následovaný řetězcem "b". Znak * není rozpoznán jako metaznač v rámci vzoru nahrazení.

Poznámka

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace nahrazení překročí časový limit určený konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud nenastavíte interval časového limitu při volání konstruktoru, je vyvolána výjimka, pokud operace překročí hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Viz také

Platí pro