Regex.Replace Метод

Определение

В указанной входной строке заменяет строки, соответствующие шаблону регулярного выражения, указанной строкой замены.

Перегрузки

Replace(String, MatchEvaluator, Int32, Int32)

В указанной входной подстроке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, String, String)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены.

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

В указанной входной строке заменяет все подстроки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

Replace(String, String, MatchEvaluator, RegexOptions)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator. Указанные параметры изменяют операцию сопоставления.

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

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

Replace(String, String, String, RegexOptions)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены. Указанные параметры изменяют операцию сопоставления.

Replace(String, MatchEvaluator)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, MatchEvaluator, Int32)

В указанной входной строке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, String, MatchEvaluator)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator.

Replace(String, String, Int32)

В указанной входной строке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.

Replace(String, String)

В указанной входной строке заменяет все строки, соответствующие шаблону регулярного выражения, указанной строкой замены.

Replace(String, String, Int32, Int32)

В указанной входной подстроке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.

Replace(String, MatchEvaluator, Int32, Int32)

В указанной входной подстроке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом 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

Параметры

input
String

Строка для поиска соответствия.

evaluator
MatchEvaluator

Пользовательский метод, анализирующий каждое совпадение и возвращающий либо исходную строку с совпадениями, либо строку замены.

count
Int32

Максимальное количество возможных случаев замены.

startat
Int32

Позиция символа во входной строке, с которой начинается поиск.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если в текущем экземпляре нет соответствия шаблону регулярных выражений, метод возвращает текущий экземпляр без изменений.

Исключения

Параметр input или evaluator имеет значение null.

Параметр startat имеет значение меньше нуля или больше длины input.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Комментарии

Метод Regex.Replace(String, MatchEvaluator, Int32, Int32) удобен для замены соответствия регулярному выражению, если выполняется любое из следующих условий:

  • Строку замены нельзя легко указать с помощью шаблона замены регулярного выражения.
  • Строка замены является результатом некоторой обработки, выполненной в сопоставленной строке.
  • Строка замены является результатом условной обработки.

Метод эквивалентен вызову Regex.Matches(String, Int32) метода и передаче делегату первых countMatch объектов из возвращаемой MatchCollectionevaluator коллекции.

Дополнительные сведения о startatсм. в разделе Примечания статьи Match(String, Int32).

Регулярное выражение — это шаблон, определенный конструктором для текущего Regex объекта .

Параметр evaluator является делегатом для определяемого пользовательского метода, который проверяет каждое совпадение. Пользовательский метод должен иметь следующую сигнатуру, чтобы соответствовать делегату MatchEvaluator .

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Пользовательский метод возвращает строку, которая заменяет совпадающие входные данные.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, заданный конструктором Regex.Regex(String, RegexOptions, TimeSpan) . Если интервал времени ожидания не задан при вызове конструктора, возникает исключение, если операция превышает любое значение времени ожидания, установленное для домена приложения, в котором Regex создается объект. Если время ожидания не определено в Regex вызове конструктора или в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

См. также раздел

Применяется к

Replace(String, String, String)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены.

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

Параметры

input
String

Строка для поиска соответствия.

pattern
String

Шаблон регулярного выражения для сопоставления.

replacement
String

Строка замены.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если для pattern не найдено соответствия в текущем экземпляре, метод возвращает текущий экземпляр без изменений.

Исключения

Произошла ошибка анализа регулярного выражения.

Значение параметра input, pattern или replacement равно null.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере определяется регулярное выражение , \s+которое соответствует одному или нескольким символам пробела. Строка замены , "", заменяет их одним символом пробела.

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.

В следующем примере метод используется Replace(String, String, String) для замены имен локальных компьютеров и дисков в UNC-пути на локальный путь к файлу. Регулярное выражение использует Environment.MachineName свойство для включения имени локального компьютера и Environment.GetLogicalDrives метод для включения имен логических дисков. Для успешного выполнения примера следует заменить литеральную строку MyMachine именем локального компьютера.

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

Шаблон регулярного выражения определяется следующим выражением:

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

В следующей таблице показано, как интерпретируется шаблон регулярного выражения.

Шаблон Описание
\\\\ Совпадение двух последовательных символов обратной косой черты (\). Так как символ обратной косой черты интерпретируется как escape-символ, каждая обратная косая черта должна экранироваться другой обратной косой чертой.
(?i:" + Environment.MachineName + ") Выполните сопоставление строки, возвращаемой свойством , без учета регистра Environment.MachineName .
(?:\.\w+)* Соответствует символу точки (.), за которой следует один или несколько символов слова. Это совпадение может встречаться ноль или более раз. Соответствующая часть выражения не фиксируется.
\\ Соответствует символу обратной косой черты (\).
((?i:[" + driveNames + "])) Выполните сопоставление без учета регистра класса символов, состоящего из отдельных букв диска. Это совпадение является первой захваченной частью выражения.
\$ Соответствует литералу знака доллара ($).

Шаблон $1 замены заменяет все совпадение первой записанной частью выражения. Это значит, что UNC-имя компьютера и диска заменяются буквой диска.

Комментарии

Статические Replace методы эквивалентны созданию объекта с указанным шаблоном Regex регулярного выражения и вызову метода Replaceэкземпляра .

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают соответствующую строку. Дополнительные сведения о регулярных выражениях см. в разделе Регулярные выражения .NET и Язык регулярных выражений — краткий справочник. Поиск совпадений начинается в начале input строки.

Параметр replacement указывает строку, которая будет заменять каждое совпадение в input. replacement может состоять из любого сочетания литерального текста и подстановок. Например, шаблон a*${test}b замены вставляет строку "a*", за которой следует подстрока, соответствующая захватываемой test группе, если она есть, за которой следует строка "b". Символ * не распознается как метасимсимуфер в шаблоне замены.

Примечание

Подстановки являются единственными элементами языка регулярных выражений, распознаваемыми в шаблоне замены. Все остальные элементы языка регулярных выражений, включая escape-символы, разрешены только в шаблонах регулярных выражений и не распознаются в шаблонах замены.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, указанный для домена приложения, в котором вызывается метод . Если время ожидания не определено в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод, чтобы определить, был ли метод заменять входную строку.

Примечания для тех, кто вызывает этот метод

Время ожидания этого метода истекает через интервал, равный значению времени ожидания по умолчанию для домена приложения, в котором он вызывается. Если значение времени ожидания не определено для домена приложения, используется значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания метода. Для замены совпадения Replace(String, String, String, RegexOptions, TimeSpan)шаблонов рекомендуется использовать статический метод , который позволяет задать интервал времени ожидания.

См. также раздел

Применяется к

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

В указанной входной строке заменяет все подстроки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

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

Параметры

input
String

Строка для поиска соответствия.

pattern
String

Шаблон регулярного выражения для сопоставления.

evaluator
MatchEvaluator

Пользовательский метод, анализирующий каждое совпадение и возвращающий либо исходную строку с совпадениями, либо строку замены.

options
RegexOptions

Побитовая комбинация значений перечисления, предоставляющих параметры для сопоставления.

matchTimeout
TimeSpan

Интервал времени ожидания или InfiniteMatchTimeout, чтобы указать, что метод не должен превышать время ожидания.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если для pattern не найдено соответствия в текущем экземпляре, метод возвращает текущий экземпляр без изменений.

Исключения

Произошла ошибка анализа регулярного выражения.

Значение параметра input, pattern или evaluator равно null.

Параметр options не является допустимой битовой комбинацией значений RegexOptions.

-или-

Значение параметра matchTimeout отрицательное, равно нулю или больше, чем приблизительно 24 дня.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере используется регулярное выражение для извлечения отдельных слов из строки, а затем используется MatchEvaluator делегат для вызова метода с именем WordScramble , который сканирует отдельные буквы в слове. Для этого WordScramble метод создает массив, содержащий символы в совпадении. Он также создает параллельный массив, который заполняется случайными числами с плавающей запятой. Массивы сортируются путем вызова Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) метода , а отсортированный массив предоставляется в качестве аргумента конструктору String класса. Эта вновь созданная строка возвращается методом WordScramble . Шаблон \w+ регулярного выражения соответствует одному или нескольким символам слова. Обработчик регулярных выражений будет продолжать добавлять символы в соответствие, пока не столкнется со словом, например символ пробела. Вызов Replace(String, String, MatchEvaluator, RegexOptions) метода включает RegexOptions.IgnorePatternWhitespace параметр , чтобы примечание в шаблоне \w+ # Matches all the characters in a word. регулярного выражения игнорирулось обработчиком регулярных выражений.

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

Комментарии

Метод Regex.Replace(String, String, MatchEvaluator, RegexOptions) полезен для замены соответствия регулярному выражению, если выполняется одно из следующих условий:

  • Значение , если строка замены не может быть легко указана шаблоном замены регулярных выражений.

  • Если строка замены является результатом некоторой обработки, выполненной в сопоставленной строке.

  • Значение , если строка замены является результатом условной обработки.

Метод эквивалентен вызову метода и передаче делегату Regex.Matches(String, String, RegexOptions) каждого Match объекта в возвращенной MatchCollection коллекции evaluator .

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают соответствующую строку. Дополнительные сведения о регулярных выражениях см . в разделах Регулярные выражения .NET и Язык регулярных выражений — краткий справочник.

Параметр evaluator является делегатом для определяемого пользовательского метода, который проверяет каждое совпадение. Настраиваемый метод должен иметь следующую сигнатуру, чтобы соответствовать делегату MatchEvaluator .

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Пользовательский метод возвращает строку, которая заменяет совпадающие входные данные.

Если указать RightToLeft для options параметра , поиск совпадений начинается в конце входной строки и перемещается влево; в противном случае поиск начинается в начале входной строки и перемещается вправо.

Параметр matchTimeout указывает, как долго метод сопоставления шаблонов должен пытаться найти совпадение до истечения времени ожидания. Установка интервала времени ожидания предотвращает появление регулярных выражений, которые зависят от чрезмерного обратного отслеживания, чтобы "перестать отвечать при обработке входных данных, содержащих почти совпадения. Дополнительные сведения см. в разделе Рекомендации по регулярным выражениям и обратному отслеживанию. Если совпадение не найдено в течение этого интервала времени, метод создает RegexMatchTimeoutException исключение. matchTimeout Переопределяет любое значение времени ожидания по умолчанию, определенное для домена приложения, в котором выполняется метод.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод, чтобы определить, был ли метод заменять входную строку.

Примечания для тех, кто вызывает этот метод

Рекомендуется задать для параметра соответствующее matchTimeout значение, например две секунды. Если отключить время ожидания, указав InfiniteMatchTimeout, подсистема регулярных выражений обеспечивает немного более высокую производительность. Однако отключать время ожидания следует только при следующих условиях:

  • Когда входные данные, обрабатываемые регулярным выражением, являются производными от известного и доверенного источника или состоят из статического текста. Это исключает текст, который был динамически введен пользователями.

  • Если шаблон регулярного выражения был тщательно протестирован, чтобы убедиться, что он эффективно обрабатывает совпадения, несоверчатые и близкие совпадения.

  • Если шаблон регулярного выражения не содержит языковых элементов, которые, как известно, приводят к чрезмерному возврату при обработке близкого совпадения.

См. также раздел

Применяется к

Replace(String, String, MatchEvaluator, RegexOptions)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом MatchEvaluator. Указанные параметры изменяют операцию сопоставления.

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

Параметры

input
String

Строка для поиска соответствия.

pattern
String

Шаблон регулярного выражения для сопоставления.

evaluator
MatchEvaluator

Пользовательский метод, анализирующий каждое совпадение и возвращающий либо исходную строку с совпадениями, либо строку замены.

options
RegexOptions

Побитовая комбинация значений перечисления, предоставляющая параметры для сопоставления.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если для pattern не найдено соответствия в текущем экземпляре, метод возвращает текущий экземпляр без изменений.

Исключения

Произошла ошибка анализа регулярного выражения.

Значение параметра input, pattern или evaluator равно null.

Параметр options не является допустимой битовой комбинацией значений RegexOptions.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере используется регулярное выражение для извлечения отдельных слов из строки, а затем используется MatchEvaluator делегат для вызова метода с именем WordScramble , который сканирует отдельные буквы в слове. Для этого WordScramble метод создает массив, содержащий символы в совпадении. Он также создает параллельный массив, который заполняется случайными числами с плавающей запятой. Массивы сортируются путем вызова Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) метода , а отсортированный массив предоставляется в качестве аргумента конструктору String класса. Эта вновь созданная строка возвращается методом WordScramble . Шаблон \w+ регулярного выражения соответствует одному или нескольким символам слова. Обработчик регулярных выражений будет продолжать добавлять символы в соответствие, пока не столкнется со словом, например символ пробела. Вызов Replace(String, String, MatchEvaluator, RegexOptions) метода включает RegexOptions.IgnorePatternWhitespace параметр , чтобы примечание в шаблоне \w+ # Matches all the characters in a word. регулярного выражения игнорирулось обработчиком регулярных выражений.

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

Комментарии

Метод Regex.Replace(String, String, MatchEvaluator, RegexOptions) полезен для замены соответствия регулярному выражению в , если выполняется одно из следующих условий:

  • Строку замены невозможно легко указать с помощью шаблона замены регулярного выражения.

  • Строка замены является результатом некоторой обработки, выполненной в сопоставленной строке.

  • Строка замены является результатом условной обработки.

Метод эквивалентен вызову метода и передаче делегату Regex.Matches(String, String, RegexOptions) каждого Match объекта в возвращенной MatchCollection коллекции evaluator .

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают соответствующую строку. Дополнительные сведения о регулярных выражениях см . в разделах Регулярные выражения .NET и Язык регулярных выражений — краткий справочник.

Параметр evaluator является делегатом для определяемого пользовательского метода, который проверяет каждое совпадение. Настраиваемый метод должен иметь следующую сигнатуру, чтобы соответствовать делегату MatchEvaluator .

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Пользовательский метод возвращает строку, которая заменяет совпадающие входные данные.

Если указать RightToLeft для options параметра , поиск совпадений начинается в конце входной строки и перемещается влево; в противном случае поиск начинается в начале входной строки и перемещается вправо.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, указанный для домена приложения, в котором вызывается метод . Если время ожидания не определено в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод, чтобы определить, был ли метод заменять входную строку.

См. также раздел

Применяется к

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

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены. Дополнительные параметры определяют параметры, которые изменяют соответствующую операцию и интервал времени ожидания, если совпадение не найдено.

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

Параметры

input
String

Строка для поиска соответствия.

pattern
String

Шаблон регулярного выражения для сопоставления.

replacement
String

Строка замены.

options
RegexOptions

Побитовая комбинация значений перечисления, предоставляющая параметры для сопоставления.

matchTimeout
TimeSpan

Интервал времени ожидания или InfiniteMatchTimeout, чтобы указать, что метод не должен превышать время ожидания.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если для pattern не найдено соответствия в текущем экземпляре, метод возвращает текущий экземпляр без изменений.

Исключения

Произошла ошибка анализа регулярного выражения.

Значение параметра input, pattern или replacement равно null.

Параметр options не является допустимой битовой комбинацией значений RegexOptions.

-или-

Значение параметра matchTimeout отрицательное, равно нулю или больше, чем приблизительно 24 дня.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере метод используется Replace(String, String, String, RegexOptions, TimeSpan) для замены имен локальных компьютеров и дисков в UNC-пути на локальный путь к файлу. Регулярное выражение использует Environment.MachineName свойство для включения имени локального компьютера и Environment.GetLogicalDrives метода для включения имен логических дисков. Все сравнения строк регулярных выражений не учитывают регистр, и время ожидания любой операции замены истекает, если совпадение не удается найти за 0,5 секунды. Для успешного выполнения примера следует заменить литеральную строку MyMachine именем локального компьютера.

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

Шаблон регулярного выражения определяется следующим выражением:

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

В следующей таблице показано, как интерпретируется шаблон регулярного выражения.

Шаблон Описание
\\\\ Совпадение двух последовательных символов обратной косой черты (\). Так как символ обратной косой черты интерпретируется как escape-символ, каждая обратная косая черта должна экранироваться другой обратной косой чертой.
+ Environment.MachineName + Соответствует строке, возвращаемой свойством Environment.MachineName .
(?:\.\w+)* Соответствует символу точки (.), за которой следует один или несколько символов слова. Это совпадение может встречаться ноль или более раз. Соответствующая часть выражения не фиксируется.
\\ Соответствует символу обратной косой черты (\).
([" + driveNames + "]) Соответствует классу символов, который состоит из отдельных букв диска. Это совпадение является первой захваченной частью выражения.
\$ Соответствует литералу знака доллара ($).

Шаблон $1 замены заменяет все совпадение первой записанной частью выражения. Это значит, что UNC-имя компьютера и диска заменяются буквой диска.

Комментарии

Статические Replace методы эквивалентны созданию объекта с указанным шаблоном Regex регулярного выражения и вызову метода Replaceэкземпляра .

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают соответствующую строку. Дополнительные сведения о регулярных выражениях см. в разделе Регулярные выражения .NET и Язык регулярных выражений — краткий справочник. Если указать RightToLeft для options параметра , поиск совпадений начинается в конце входной строки и перемещается влево; в противном случае поиск начинается в начале входной строки и перемещается вправо.

Параметр replacement указывает строку, которая будет заменять каждое совпадение в input. replacement может состоять из любого сочетания литерального текста и подстановок. Например, шаблон a*${test}b замены вставляет строку "a*", за которой следует подстрока, соответствующая test захватываемой группе , если она имеется, за которой следует строка "b". Символ * не распознается как метасимсимактер в шаблоне замены.

Примечание

Подстановки — это единственные элементы языка регулярных выражений, распознаваемые в шаблоне замены. Все остальные элементы языка регулярных выражений, включая экранирование символов, разрешены только в шаблонах регулярных выражений и не распознаются в шаблонах замены.

Параметр matchTimeout указывает, как долго метод сопоставления шаблонов должен пытаться найти совпадение до истечения времени ожидания. Установка интервала тайм-аута предотвращает появление регулярных выражений, которые зависят от чрезмерного отслеживания с возвратом, чтобы перестать отвечать на запросы при обработке входных данных, содержащих близкие совпадения. Дополнительные сведения см. в статье Рекомендации по использованию регулярных выражений и обратного отслеживания. Если совпадение не найдено в течение этого интервала времени, метод создает RegexMatchTimeoutException исключение. matchTimeout Переопределяет любое значение времени ожидания по умолчанию, определенное для домена приложения, в котором выполняется метод.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

Примечания для тех, кто вызывает этот метод

Рекомендуется задать для параметра соответствующее matchTimeout значение, например две секунды. Если отключить тайм-ауты, указав InfiniteMatchTimeout, обработчик регулярных выражений обеспечивает немного лучшую производительность. Однако отключать время ожидания следует только при следующих условиях:

  • Если входные данные, обработанные регулярным выражением, являются производными от известного и доверенного источника или состоят из статического текста. Это исключает текст, который был динамически введен пользователями.

  • Если шаблон регулярного выражения тщательно протестирован, чтобы убедиться, что он эффективно обрабатывает совпадения, несоответствия и близкие совпадения.

  • Если шаблон регулярного выражения не содержит языковых элементов, которые, как известно, вызывают чрезмерное восстановление при обработке близкого совпадения.

См. также раздел

Применяется к

Replace(String, String, String, RegexOptions)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, указанной строкой замены. Указанные параметры изменяют операцию сопоставления.

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

Параметры

input
String

Строка для поиска соответствия.

pattern
String

Шаблон регулярного выражения для сопоставления.

replacement
String

Строка замены.

options
RegexOptions

Побитовая комбинация значений перечисления, предоставляющая параметры для сопоставления.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если для pattern не найдено соответствия в текущем экземпляре, метод возвращает текущий экземпляр без изменений.

Исключения

Произошла ошибка анализа регулярного выражения.

Значение параметра input, pattern или replacement равно null.

Параметр options не является допустимой битовой комбинацией значений RegexOptions.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере метод используется Replace(String, String, String, RegexOptions) для замены имен локальных компьютеров и дисков в UNC-пути на локальный путь к файлу. Регулярное выражение использует Environment.MachineName свойство для включения имени локального компьютера и Environment.GetLogicalDrives метод для включения имен логических дисков. Все сравнения строк регулярных выражений не учитывают регистр. Для успешного выполнения примера следует заменить литеральную строку MyMachine именем локального компьютера.

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

Шаблон регулярного выражения определяется следующим выражением:

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

В следующей таблице показано, как интерпретируется шаблон регулярного выражения.

Шаблон Описание
\\\\ Совпадение двух последовательных символов обратной косой черты (\). Так как символ обратной косой черты интерпретируется как escape-символ, каждая обратная косая черта должна экранироваться другой обратной косой чертой.
+ Environment.MachineName + Соответствует строке, возвращаемой свойством Environment.MachineName .
(?:\.\w+)* Соответствует символу точки (.), за которой следует один или несколько символов слова. Это совпадение может встречаться ноль или более раз. Соответствующая часть выражения не фиксируется.
\\ Соответствует символу обратной косой черты (\).
([" + driveNames + "]) Соответствует классу символов, который состоит из отдельных букв диска. Это совпадение является первой захваченной частью выражения.
\$ Соответствует литералу знака доллара ($).

Шаблон $1 замены заменяет все совпадение первой записанной частью выражения. Это значит, что UNC-имя компьютера и диска заменяются буквой диска.

Комментарии

Статические Replace методы эквивалентны созданию объекта с указанным шаблоном Regex регулярного выражения и вызову метода Replaceэкземпляра .

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают соответствующую строку. Дополнительные сведения о регулярных выражениях см. в разделе Регулярные выражения .NET и Язык регулярных выражений — краткий справочник. Если указать RightToLeft для options параметра , поиск совпадений начинается в конце входной строки и перемещается влево; в противном случае поиск начинается в начале входной строки и перемещается вправо.

Параметр replacement указывает строку, которая будет заменять каждое совпадение в input. replacement может состоять из любого сочетания литерального текста и подстановок. Например, шаблон a*${test}b замены вставляет строку "a*", за которой следует подстрока, соответствующая test захватываемой группе , если она имеется, за которой следует строка "b". Символ * не распознается как метасимсимактер в шаблоне замены.

Примечание

Подстановки — это единственные элементы языка регулярных выражений, распознаваемые в шаблоне замены. Все остальные элементы языка регулярных выражений, включая экранирование символов, разрешены только в шаблонах регулярных выражений и не распознаются в шаблонах замены.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, указанный для домена приложения, в котором вызывается метод . Если в свойствах домена приложения не определено время ожидания или значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

Примечания для тех, кто вызывает этот метод

Время ожидания этого метода истекает через интервал, равный значению времени ожидания по умолчанию для домена приложения, в котором он вызывается. Если значение времени ожидания не определено для домена приложения, используется значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания метода. Для замены совпадения Replace(String, String, String, RegexOptions, TimeSpan)шаблонов рекомендуется использовать статический метод , который позволяет задать интервал времени ожидания.

См. также раздел

Применяется к

Replace(String, MatchEvaluator)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом 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

Параметры

input
String

Строка для поиска соответствия.

evaluator
MatchEvaluator

Пользовательский метод, анализирующий каждое совпадение и возвращающий либо исходную строку с совпадениями, либо строку замены.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если в текущем экземпляре нет соответствия шаблону регулярных выражений, метод возвращает текущий экземпляр без изменений.

Исключения

Параметр input или evaluator имеет значение null.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере кода отображается исходная строка, сопоставляется каждое слово в исходной строке, преобразуется первый символ каждого совпадения в верхний регистр, а затем отображается преобразованная строка.

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]

Комментарии

Метод Regex.Replace(String, MatchEvaluator) удобен для замены соответствия регулярному выражению, если выполняется любое из следующих условий:

  • Строку замены нельзя легко указать с помощью шаблона замены регулярного выражения.

  • Строка замены является результатом некоторой обработки, выполненной в сопоставленной строке.

  • Строка замены является результатом условной обработки.

Метод эквивалентен вызову Regex.Matches(String) метода и передаче делегату каждого Match объекта из возвращаемой MatchCollectionevaluator коллекции.

Регулярное выражение — это шаблон, определенный конструктором для текущего Regex объекта .

Параметр evaluator является делегатом для определяемого пользовательского метода, который проверяет каждое совпадение. Пользовательский метод должен иметь следующую сигнатуру, чтобы соответствовать делегату MatchEvaluator .

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Пользовательский метод возвращает строку, которая заменяет совпадающие входные данные.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, заданный конструктором Regex.Regex(String, RegexOptions, TimeSpan) . Если интервал времени ожидания не задан при вызове конструктора, возникает исключение, если операция превышает любое значение времени ожидания, установленное для домена приложения, в котором Regex создается объект. Если время ожидания не определено в Regex вызове конструктора или в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

См. также раздел

Применяется к

Replace(String, MatchEvaluator, Int32)

В указанной входной строке заменяется указанное максимальное количество строк, соответствующих шаблону регулярного выражения, строкой, возвращенной делегатом 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

Параметры

input
String

Строка для поиска соответствия.

evaluator
MatchEvaluator

Пользовательский метод, анализирующий каждое совпадение и возвращающий либо исходную строку с совпадениями, либо строку замены.

count
Int32

Максимальное количество возможных случаев замены.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если в текущем экземпляре нет соответствия шаблону регулярных выражений, метод возвращает текущий экземпляр без изменений.

Исключения

Параметр input или evaluator имеет значение null.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере используется регулярное выражение для намеренного опечатки половины слов в списке. Оно использует регулярное выражение \w*(ie|ei)\w* для сопоставления слов, включающих символы "ie" или "ei". Он передает первую половину совпадающих слов ReverseLetter в метод , который, в свою очередь, использует Replace(String, String, String, RegexOptions) метод для обратного обращения "i" и "e" в сопоставленной строке. Оставшиеся слова остаются без изменений.

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

Определение регулярного выражения \w*(ie|ei)\w* показано в таблице ниже.

Шаблон Описание
\w* Совпадение с нулем или большим числом буквенных символов.
(ie|ei) Совпадение с "ie" или "ei".
\w* Совпадение с нулем или большим числом буквенных символов.

Шаблон ([ie])([ie]) регулярного ReverseLetter выражения в методе соответствует первому значению "i" или "e" в дифтонге "ie" или "ei" и присваивает букву первой захватываемой группе. Он соответствует второму "i" или "e" и назначает букву второй захватывающей группе. Затем два символа возвращаются обратно путем вызова Replace(String, String, String) метода с шаблоном $2$1замены .

Комментарии

Метод Regex.Replace(String, MatchEvaluator, Int32) удобен для замены соответствия регулярному выражению, если выполняется любое из следующих условий:

  • Строку замены нельзя легко указать с помощью шаблона замены регулярного выражения.

  • Строка замены является результатом некоторой обработки, выполненной в сопоставленной строке.

  • Строка замены является результатом условной обработки.

Метод эквивалентен вызову Regex.Matches(String) метода и передаче делегату первых countMatch объектов из возвращаемой MatchCollectionevaluator коллекции.

Регулярное выражение — это шаблон, определенный конструктором для текущего Regex объекта .

Параметр evaluator является делегатом для определяемого пользовательского метода, который проверяет каждое совпадение. Пользовательский метод должен иметь следующую сигнатуру, чтобы соответствовать делегату MatchEvaluator .

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Пользовательский метод возвращает строку, которая заменяет совпадающие входные данные.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, заданный конструктором Regex.Regex(String, RegexOptions, TimeSpan) . Если интервал времени ожидания не задан при вызове конструктора, возникает исключение, если операция превышает любое значение времени ожидания, установленное для домена приложения, в котором Regex создается объект. Если время ожидания не определено в Regex вызове конструктора или в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

См. также раздел

Применяется к

Replace(String, String, MatchEvaluator)

В указанной входной строке заменяет все строки, соответствующие указанному регулярному выражению, строкой, возвращенной делегатом 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

Параметры

input
String

Строка для поиска соответствия.

pattern
String

Шаблон регулярного выражения для сопоставления.

evaluator
MatchEvaluator

Пользовательский метод, анализирующий каждое совпадение и возвращающий либо исходную строку с совпадениями, либо строку замены.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если для pattern не найдено соответствия в текущем экземпляре, метод возвращает текущий экземпляр без изменений.

Исключения

Произошла ошибка анализа регулярного выражения.

Значение параметра input, pattern или evaluator равно null.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере используется регулярное выражение для извлечения отдельных слов из строки, а затем используется MatchEvaluator делегат для вызова метода с именем WordScramble , который выполняет поиск отдельных букв в слове. Для этого WordScramble метод создает массив, содержащий символы в совпадении. Он также создает параллельный массив, который заполняется случайными числами с плавающей запятой. Массивы сортируются путем вызова Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) метода , а отсортированный массив предоставляется в качестве аргумента конструктору String класса. Затем эта вновь созданная строка возвращается методом WordScramble . Шаблон \w+ регулярного выражения соответствует одному или нескольким символам слова; обработчик регулярных выражений будет продолжать добавлять символы в совпадение, пока не обнаружит символ, отличный от слова, например символ пробела.

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

Комментарии

Метод Regex.Replace(String, String, MatchEvaluator) удобен для замены соответствия регулярному выражению, если выполняется любое из следующих условий:

  • Строку замены нельзя легко указать с помощью шаблона замены регулярного выражения.

  • Строка замены является результатом некоторой обработки, выполненной в сопоставленной строке.

  • Строка замены является результатом условной обработки.

Метод эквивалентен вызову Regex.Matches(String, String) метода и передаче делегату каждого Match объекта из возвращаемой MatchCollectionevaluator коллекции.

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают соответствующую строку. Дополнительные сведения о регулярных выражениях см. в разделе Регулярные выражения .NET и Язык регулярных выражений — краткий справочник.

Параметр evaluator является делегатом для определяемого пользовательского метода, который проверяет каждое совпадение. Пользовательский метод должен иметь следующую сигнатуру, чтобы соответствовать делегату MatchEvaluator .

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Пользовательский метод возвращает строку, которая заменяет совпадающие входные данные.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, указанный для домена приложения, в котором вызывается метод . Если в свойствах домена приложения не определено время ожидания или значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

Примечания для тех, кто вызывает этот метод

Время ожидания этого метода истекает через интервал, равный значению времени ожидания по умолчанию для домена приложения, в котором он вызывается. Если значение времени ожидания не определено для домена приложения, используется значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания метода. Рекомендуемый статический метод для оценки и замены совпадения шаблонов — Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), который позволяет задать интервал времени ожидания.

См. также раздел

Применяется к

Replace(String, String, Int32)

В указанной входной строке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.

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

Параметры

input
String

Строка для поиска соответствия.

replacement
String

Строка замены.

count
Int32

Максимальное количество возможных случаев замены.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если в текущем экземпляре нет соответствия шаблону регулярных выражений, метод возвращает текущий экземпляр без изменений.

Исключения

Параметр input или replacement имеет значение null.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере первые пять вхождений повторяющихся символов заменяются одним символом. Шаблон (\w)\1 регулярного выражения сопоставляет последовательные вхождения одного символа и назначает первое вхождение первой захватываемой группе. Шаблон $1 замены заменяет все совпадение первой захваченной группой.

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'

Комментарии

Поиск совпадений начинается в начале input строки. Регулярное выражение — это шаблон, определенный конструктором для текущего Regex объекта . Если count значение отрицательное, замена продолжается до конца строки. Если count значение превышает количество совпадений, все совпадения заменяются.

Параметр replacement указывает строку, которая будет заменять первые count совпадения в input. replacement может состоять из любого сочетания литерального текста и подстановок. Например, шаблон a*${test}b замены вставляет строку "a*", за которой следует подстрока, соответствующая test захватываемой группе , если она имеется, за которой следует строка "b". Символ * не распознается как метасимсимактер в шаблоне замены.

Примечание

Подстановки — это единственные элементы языка регулярных выражений, распознаваемые в шаблоне замены. Все остальные элементы языка регулярных выражений, включая экранирование символов, разрешены только в шаблонах регулярных выражений и не распознаются в шаблонах замены.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, заданный конструктором Regex.Regex(String, RegexOptions, TimeSpan) . Если интервал времени ожидания не задан при вызове конструктора, возникает исключение, если операция превышает любое значение времени ожидания, установленное для домена приложения, в котором Regex создается объект. Если время ожидания не определено в Regex вызове конструктора или в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

См. также раздел

Применяется к

Replace(String, String)

В указанной входной строке заменяет все строки, соответствующие шаблону регулярного выражения, указанной строкой замены.

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

Параметры

input
String

Строка для поиска соответствия.

replacement
String

Строка замены.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если в текущем экземпляре нет соответствия шаблону регулярных выражений, метод возвращает текущий экземпляр без изменений.

Исключения

Параметр input или replacement имеет значение null.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере определяется регулярное выражение , \s+которое соответствует одному или нескольким символам пробела. Строка замены , "", заменяет их одним символом пробела.

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.

В следующем примере определяется регулярное выражение (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?и шаблон замены , $2который удаляет начальный или конечный символ валюты из числового значения.

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'

Возможные интерпретации регулярного выражения показаны в следующей таблице.

Шаблон Описание
\p{Sc} Соответствует символу валюты. {Sc} обозначает любой символ, который является членом символа Юникода, категория Валюта.
\s? Совпадение с нулем или одним символом пробела.
(\p{Sc}\s?)? Соответствует нулю или одному вхождениям сочетания символа валюты, за которым следует ноль или один пробел. Это первая группа записи.
\d+ Совпадение с одной или несколькими десятичными цифрами.
\.? Соответствует нулю или одному вхождению точки (используется в качестве десятичного разделителя).
((?<=\.)\d+)? Если точка является предыдущим символом, совпадет с одной или несколькими десятичными цифрами. Этот шаблон можно сопоставить либо ноль, либо один раз.
(\d+\.?((?<=\.)\d+)?) Соответствует шаблону одной или нескольких десятичных цифр, за которыми следует необязательная точка и дополнительные десятичные цифры. Это вторая группа записи. Вызов Replace(String, String) метода заменяет все совпадение значением этой захватываемой группы.
(?(1)|\s?\p{Sc})? Если первая захваченная группа существует, соответствует пустой строке. В противном случае соответствует нулю или одному символу пробела, за которым следует символ валюты.

Комментарии

Поиск совпадений начинается в начале input строки. Регулярное выражение — это шаблон, определенный конструктором для текущего Regex объекта .

Параметр replacement указывает строку, которая будет заменять каждое совпадение в input. replacement может состоять из любого сочетания литерального текста и подстановок. Например, шаблон a*${test}b замены вставляет строку "a*", за которой следует подстрока, соответствующая test захватываемой группе , если она имеется, за которой следует строка "b". Символ * не распознается как метасимсимактер в шаблоне замены.

Примечание

Подстановки — это единственные элементы языка регулярных выражений, распознаваемые в шаблоне замены. Все остальные элементы языка регулярных выражений, включая экранирование символов, разрешены только в шаблонах регулярных выражений и не распознаются в шаблонах замены.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, заданный конструктором Regex.Regex(String, RegexOptions, TimeSpan) . Если интервал времени ожидания не задан при вызове конструктора, возникает исключение, если операция превышает любое значение времени ожидания, установленное для домена приложения, в котором Regex создается объект. Если время ожидания не определено в Regex вызове конструктора или в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод , чтобы определить, внес ли метод какие-либо замену входной строке.

См. также раздел

Применяется к

Replace(String, String, Int32, Int32)

В указанной входной подстроке заменяет указанное максимальное количество строк, соответствующих шаблону регулярного выражения, указанной строкой замены.

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

Параметры

input
String

Строка для поиска соответствия.

replacement
String

Строка замены.

count
Int32

Максимальное возможное количество случаев замены.

startat
Int32

Позиция символа во входной строке, с которой начинается поиск.

Возвращаемое значение

Новая строка, идентичная входной строке, за исключением того что строка замены занимает место каждой соответствующей строки. Если в текущем экземпляре нет соответствия шаблону регулярных выражений, метод возвращает текущий экземпляр без изменений.

Исключения

Параметр input или replacement имеет значение null.

Параметр startat имеет значение меньше нуля или больше длины input.

Время ожидания истекло. Дополнительные сведения о времени ожидания см. в разделе "Примечания".

Примеры

В следующем примере двойные пробелы все, кроме первой строки строки. Он определяет шаблон регулярного выражения , ^.*$который соответствует строке текста, вызывает Match(String) метод для сопоставления с первой строкой строки и использует Match.Index свойства и Match.Count для определения начальной позиции второй строки.

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.

Шаблон регулярного выражения ^.*$ определяется, как показано в следующей таблице.

Шаблон Описание
^ Соответствует началу строки. (Обратите внимание, что Regex экземпляр объекта был создан с помощью параметра ; в RegexOptions.Multiline противном случае этот класс символов будет соответствовать только началу входной строки.)
.* Соответствует любому символу ноль или более раз.
$ Соответствует концу строки. (Обратите внимание, что Regex экземпляр объекта был создан с помощью параметра ; в RegexOptions.Multiline противном случае этот класс символов будет соответствовать только началу входной строки.)

Строка замены (vbCrLf + "$&" в Visual Basic, "\n$&" в C#) добавляет новую строку перед соответствующей строкой. Обратите внимание, что \n в примере C# компилятор C# интерпретирует как символ новой строки; он не представляет escape символов регулярного выражения.

Комментарии

Поиск совпадений начинается в строке input в позиции, указанной параметром startat . Регулярное выражение — это шаблон, определенный конструктором для текущего Regex объекта. Если count значение отрицательное, замена продолжается до конца строки. Если count число совпадений превышается, все совпадения заменяются.

Дополнительные сведения о startatсм. в разделе "Примечания" статьи Match(String, Int32).

Параметр replacement задает строку, которая будет заменять каждое совпадение в input. replacement может состоять из любого сочетания литерального текста и подстановок. Например, шаблон a*${test}b замены вставляет строку "a*", за которой следует подстрока, соответствующая захватываемой test группе, если она есть, за которой следует строка "b". Символ * не распознается как метасимсимуфер в шаблоне замены.

Примечание

Подстановки являются единственными элементами языка регулярных выражений, распознаваемыми в шаблоне замены. Все остальные элементы языка регулярных выражений, включая escape-символы, разрешены только в шаблонах регулярных выражений и не распознаются в шаблонах замены.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции замены превышает интервал времени ожидания, заданный конструктором Regex.Regex(String, RegexOptions, TimeSpan) . Если при вызове конструктора не задан интервал времени ожидания, создается исключение, если операция превышает любое значение времени ожидания, установленное для домена приложения, в котором Regex создается объект. Если время ожидания не определено в Regex вызове конструктора или в свойствах домена приложения или если значение времени ожидания равно Regex.InfiniteMatchTimeout, исключение не создается.

Так как метод возвращает input без изменений, если совпадения нет, можно использовать Object.ReferenceEquals метод, чтобы определить, был ли метод заменять входную строку.

См. также раздел

Применяется к