Regex.Replace Metoda

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);

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

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud se pattern neshoduje v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

Příklady

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

Vzor 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í vytvoření Regex objektu se zadaným vzorem regulárního výrazu a volání metody instance Replace.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční. Pokud zadáte RightToLeft pro parametr options, hledání shod začíná na konci vstupního řetězce a přesune se doleva; jinak 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 se mohou skládat z jakékoli kombinace literálového textu a náhrad. Například vzor nahrazení a*${test}b vloží řetězec "a*" následovaný podřetězcem, který odpovídá test zachytávání skupiny, pokud existuje, a řetězec "b". Znak * není rozpoznán jako metacharakter v rámci náhradního vzoru.

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 není definován žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Poznámky pro volající

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

Viz také

• RegexOptions
• nahrazení v regulárních výrazech
• elementy jazyka regulárních výrazů

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

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

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud se pattern neshoduje v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

Příklady

Následující příklad používá metodu Replace(String, String, String, RegexOptions, TimeSpan) k nahrazení názvů místních počítačů a jednotek v cestě UNC místní cestou k souboru. Regulární výraz používá vlastnost Environment.MachineName k zahrnutí názvu místního počítače a metody Environment.GetLogicalDrives zahrnout názvy logických jednotek. Všechna porovnání řetězců regulárních výrazů nerozlišují malá a velká písmena a všechny operace nahrazení vyprší, pokud se shoda nenašla za 0,5 sekundy. Pokud chcete úspěšně spustit příklad, měli byste nahradit literálový řetězec "MyMachine" 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 interpretuje vzor regulárního výrazu.

Vzor 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í vytvoření Regex objektu se zadaným vzorem regulárního výrazu a volání metody instance Replace.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční. Pokud zadáte RightToLeft pro parametr options, hledání shod začíná na konci vstupního řetězce a přesune se doleva; jinak 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 se mohou skládat z jakékoli kombinace literálového textu a náhrad. Například vzor nahrazení a*${test}b vloží řetězec "a*" následovaný podřetězcem, který odpovídá test zachytávání skupiny, pokud existuje, a řetězec "b". Znak * není rozpoznán jako metacharakter v rámci náhradního vzoru.

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

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

Poznámky pro volající

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

• Pokud 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é dynamicky zadali.

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

• Pokud vzor regulárního výrazu neobsahuje žádné prvky jazyka, o kterých je známo, že při zpracování blízké shody způsobují nadměrné navracení.

Viz také

• RegexOptions
• nahrazení v regulárních výrazech
• elementy jazyka regulárních výrazů
• navracení v regulárních výrazech
• osvědčené postupy pro regulární výrazy v rozhraní .NET

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

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

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

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

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

Parametry

Návraty

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

Výjimky

Poznámky

Metoda Regex.Replace(String, MatchEvaluator, Int32, Int32) je užitečná pro nahrazení shody regulárního výrazu, pokud je splněna 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 evaluator delegátu.

Další podrobnosti o startatnaleznete v části Poznámky Match(String, Int32).

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vaše 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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• MatchEvaluator
• nahrazení v regulárních výrazech
• jazyk regulárních výrazů – stručná referenční

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

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

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

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

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

Parametry

Návraty

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

Výjimky

Příklady

Následující příklad používá regulární výraz k extrahování jednotlivých slov z řetězce a pak používá MatchEvaluator delegát k volání metody pojmenované WordScramble, která zakóduje jednotlivá písmena ve slově. K tomu WordScramble metoda vytvoří pole, které obsahuje znaky ve shodě. Vytvoří také paralelní pole, které naplní náhodnými čísly s plovoucí desetinou čárkou. Pole jsou seřazena voláním metody Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) a seřazené pole je poskytováno jako argument konstruktoru třídy String. Tento nově vytvořený řetězec se pak vrátí metodou WordScramble. Vzor regulárního výrazu \w+ 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 neslovný znak, například prázdný znak. Volání metody Replace(String, String, MatchEvaluator, RegexOptions) obsahuje možnost RegexOptions.IgnorePatternWhitespace tak, aby komentář v vzoru regulárního výrazu \w+ # Matches all the characters in a word. byl 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();
      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á 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, RegexOptions) metody a předání každého Match objektu ve vrácené MatchCollection kolekci evaluator delegátu.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vaše vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Pokud zadáte RightToLeft pro parametr options, hledání shod začíná na konci vstupního řetězce a přesune se doleva; jinak hledání začíná na začátku vstupního řetězce a přesune se doprava.

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 není definován žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• MatchEvaluator
• RegexOptions
• nahrazení v regulárních výrazech
• elementy jazyka regulárních výrazů

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

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

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

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

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud se pattern neshoduje v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

Příklady

Následující příklad používá regulární výraz k extrahování jednotlivých slov z řetězce a pak používá MatchEvaluator delegát k volání metody pojmenované WordScramble, která zakóduje jednotlivá písmena ve slově. K tomu WordScramble metoda vytvoří pole, které obsahuje znaky ve shodě. Vytvoří také paralelní pole, které naplní náhodnými čísly s plovoucí desetinou čárkou. Pole jsou seřazena voláním metody Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) a seřazené pole je poskytováno jako argument konstruktoru třídy String. Tento nově vytvořený řetězec se pak vrátí metodou WordScramble. Vzor regulárního výrazu \w+ 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 neslovný znak, například prázdný znak. Volání metody Replace(String, String, MatchEvaluator, RegexOptions) obsahuje možnost RegexOptions.IgnorePatternWhitespace tak, aby komentář v vzoru regulárního výrazu \w+ # Matches all the characters in a word. byl 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á pro nahrazení shody regulárního výrazu, pokud je splněna některá z následujících podmínek:

• Pokud náhradní řetězec nelze snadno určit vzorem nahrazení regulárního výrazu.

• Pokud náhradní řetězec vznikne z nějakého zpracování provedeného u odpovídajícího řetězce.

• Pokud náhradní řetězec pochází z 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 evaluator delegátu.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vaše vlastní metoda vrátí řetězec, který nahradí odpovídající vstup.

Pokud zadáte RightToLeft pro parametr options, hledání shod začíná na konci vstupního řetězce a přesune se doleva; jinak hledání začíná na začátku vstupního řetězce a přesune se doprava.

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

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

Poznámky pro volající

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

• Pokud 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é dynamicky zadali.

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

• Pokud vzor regulárního výrazu neobsahuje žádné prvky jazyka, o kterých je známo, že při zpracování blízké shody způsobují nadměrné navracení.

Viz také

• RegexOptions
• nahrazení v regulárních výrazech
• elementy jazyka regulárních výrazů
• navracení v regulárních výrazech
• osvědčené postupy pro regulární výrazy v rozhraní .NET

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);

public string Replace (string input, string replacement, int count, int startat);

member this.Replace : string * string * int * int -> string

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

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud vzor regulárního výrazu neodpovídá v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

Příklady

Následující příklad dvojité mezery všechny kromě prvního řádku řetězce. Definuje vzor regulárního výrazu, ^.*$, který odpovídá řádku textu, volá Match(String) metodu tak, aby odpovídala prvnímu řádku řetězce, a používá Match.Index a Match.Count vlastnosti 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 definován, jak je znázorněno v následující tabulce.

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

Poznámky

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

Další podrobnosti o startatnaleznete v části Poznámky Match(String, Int32).

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

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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• nahrazení v regulárních výrazech
• jazyk regulárních výrazů – stručná referenční

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);

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

static member Replace : string * string * string -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String) As String

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud se pattern neshoduje v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

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 ", ", nahradí je 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í názvů místních počítačů a jednotek v cestě UNC místní cestou k souboru. Regulární výraz používá vlastnost Environment.MachineName k zahrnutí názvu místního počítače a Environment.GetLogicalDrives metoda zahrnout názvy logických jednotek. Pokud chcete úspěšně spustit příklad, měli byste nahradit literálový řetězec "MyMachine" 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 interpretuje vzor regulárního výrazu.

Vzor 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í vytvoření Regex objektu se zadaným vzorem regulárního výrazu a volání metody instance Replace.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční. Hledání shod začíná na začátku řetězce input.

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

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 není definován žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Poznámky pro volající

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

Viz také

• nahrazení v regulárních výrazech
• elementy jazyka regulárních výrazů

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

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

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

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

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

Parametry

Návraty

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

Výjimky

Příklady

Následující příklad používá regulární výraz k extrahování jednotlivých slov z řetězce a pak používá MatchEvaluator delegát k volání metody pojmenované WordScramble, která zakóduje jednotlivá písmena ve slově. K tomu WordScramble metoda vytvoří pole, které obsahuje znaky ve shodě. Vytvoří také paralelní pole, které naplní náhodnými čísly s plovoucí desetinou čárkou. Pole jsou seřazena voláním metody Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) a seřazené pole je poskytováno jako argument konstruktoru třídy String. Tento nově vytvořený řetězec se pak vrátí metodou WordScramble. Vzor regulárního výrazu \w+ 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 neslovný znak, 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 je splněna 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 evaluator delegátu.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vaše 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 zadaný pro doménu aplikace, ve které je volána metoda. Pokud není definován žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Poznámky pro volající

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

Viz také

• MatchEvaluator
• nahrazení v regulárních výrazech
• elementy jazyka regulárních výrazů

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);

public string Replace (string input, string replacement, int count);

member this.Replace : string * string * int -> string

Public Function Replace (input As String, replacement As String, count As Integer) As String

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud vzor regulárního výrazu neodpovídá v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

Příklady

Následující příklad nahrazuje prvních pět výskytů duplicitních znaků jedním znakem. Vzor regulárního výrazu (\w)\1 odpovídá po sobě jdoucím výskytům jednoho znaku a přiřadí první výskyt první skupině zachycení. Vzor 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 řetězce input. Regulární výraz je vzor, který je definován konstruktorem pro aktuální Regex objektu. Pokud je count negativní, nahrazení pokračuje na konec řetězce. Pokud count překročí počet shod, nahradí se všechny shody.

Parametr replacement určuje řetězec, který má nahradit první count shody v input. replacement se mohou skládat z jakékoli kombinace literálového textu a náhrad. Například vzor nahrazení a*${test}b vloží řetězec "a*" následovaný podřetězcem, který odpovídá test zachytávání skupiny, pokud existuje, a řetězec "b". Znak * není rozpoznán jako metacharakter v rámci náhradního vzoru.

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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• jazyk regulárních výrazů – stručná referenční
• nahrazení v regulárních výrazech

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

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

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

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

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

Parametry

Návraty

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

Výjimky

Příklady

Následující příklad kódu zobrazí původní řetězec, odpovídá každému slovu 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 je splněna 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 evaluator delegátu.

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vaše 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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• MatchEvaluator
• nahrazení v regulárních výrazech
• jazyk regulárních výrazů – stručná referenční

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);

public string Replace (string input, string replacement);

member this.Replace : string * string -> string

Public Function Replace (input As String, replacement As String) As String

Parametry

Návraty

Nový řetězec, který je shodný se vstupním řetězcem, s výjimkou toho, že náhradní řetězec se umístí na místo každého odpovídajícího řetězce. Pokud vzor regulárního výrazu neodpovídá v aktuální instanci, vrátí metoda aktuální instanci beze změny.

Výjimky

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 ", ", nahradí je 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 náhradní vzor, $2, který odebere počáteční nebo koncový symbol měny z číselné hodnoty.

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 se interpretuje, jak je znázorněno v následující tabulce.

Poznámky

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

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

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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• jazyk regulárních výrazů – stručná referenční
• nahrazení v regulárních výrazech

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

Zdroj:

Regex.Replace.cs

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

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

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

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

Parametry

Návraty

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

Výjimky

Příklady

Následující příklad používá regulární výraz k úmyslně chybně napsané polovině 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 metodě ReverseLetter, která zase používá metodu Replace(String, String, String, RegexOptions) k obrácení "i" a "e" v odpovídajícím řetězci. Zbývající slova zůstávají 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, jak je znázorněno v následující tabulce.

Vzor regulárního výrazu ([ie])([ie]) v metodě ReverseLetter odpovídá prvnímu znaku "i" nebo "e" v diphthongu "ie" nebo "ei" a přiřadí písmeno první zachycené skupině. Odpovídá druhému znaku "i" nebo "e" a přiřadí písmeno druhé skupině zachycení. Dva znaky jsou pak obráceny voláním metody Replace(String, String, String) 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 je splněna 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 evaluator delegátu.

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Vaše 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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

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

Viz také

• MatchEvaluator
• nahrazení v regulárních výrazech
• jazyk regulárních výrazů – stručná referenční