Regex.Replace Метод

Ссылка

Определение

Пространство имен:: System.Text.RegularExpressions

Сборка:: System.Text.RegularExpressions.dll

Сборка:: System.dll

Сборка:: netstandard.dll

Важно!

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

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

Перегрузки

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

Replace(String, String, String, RegexOptions)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

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

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

Параметры

input: String

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

pattern: String

Шаблон регулярного выражения, соответствующий.

replacement: String

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

options: RegexOptions

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

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

String

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

Исключения

ArgumentException

Произошла ошибка синтаксического анализа регулярных выражений.

ArgumentNullException

input, patternили replacementnull.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Примеры

В следующем примере метод 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 и диска буквой диска.

Параметр 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, String, String, RegexOptions, TimeSpan)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

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

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

Параметры

input: String

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

pattern: String

Шаблон регулярного выражения, соответствующий.

replacement: String

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

options: RegexOptions

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

matchTimeout: TimeSpan

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

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

String

Исключения

ArgumentException

Произошла ошибка синтаксического анализа регулярных выражений.

ArgumentNullException

input, patternили replacementnull.

ArgumentOutOfRangeException

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

-или-

matchTimeout отрицательно, ноль или больше примерно 24 дней.

RegexMatchTimeoutException

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

Примеры

В следующем примере метод 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 + "])`	Соответствует классу символов, состоящему из отдельных букв дисков. Это совпадение является первым захваченным вложенным выражением.
`\$`	Соответствует знаку литерального доллара (`$`) символу.

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

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

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

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

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

RegexOptions
замены в регулярных выражениях
элементы языка регулярных выражений
обратное отслеживание в регулярных выражений
рекомендации по регулярным выражениям в .NET

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

Replace(String, MatchEvaluator, Int32, Int32)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

String

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

Исключения

ArgumentNullException

input или evaluatornull.

ArgumentOutOfRangeException

startat меньше нуля или больше длины input.

RegexMatchTimeoutException

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

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

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

Дополнительные сведения о 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, исключение не возникает.

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

MatchEvaluator
замены в регулярных выражениях
язык регулярных выражений — краткий справочник

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

Replace(String, String, MatchEvaluator, RegexOptions)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

String

Исключения

ArgumentException

Произошла ошибка синтаксического анализа регулярных выражений.

ArgumentNullException

input, patternили evaluatornull.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Примеры

В следующем примере используется регулярное выражение для извлечения отдельных слов из строки, а затем используется делегат 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.Matches(String, String, RegexOptions) и передаче каждого объекта Match в возвращенной коллекции MatchCollection делегату evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

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

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

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

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

String

Исключения

ArgumentException

Произошла ошибка синтаксического анализа регулярных выражений.

ArgumentNullException

input, patternили evaluatornull.

ArgumentOutOfRangeException

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

-или-

matchTimeout отрицательно, ноль или больше примерно 24 дней.

RegexMatchTimeoutException

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

Примеры

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

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

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

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

RegexOptions
замены в регулярных выражениях
элементы языка регулярных выражений
обратное отслеживание в регулярных выражений
рекомендации по регулярным выражениям в .NET

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

Replace(String, String, Int32, Int32)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

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

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

Параметры

input: String

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

replacement: String

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

count: Int32

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

startat: Int32

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

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

String

Исключения

ArgumentNullException

input или replacementnull.

ArgumentOutOfRangeException

startat меньше нуля или больше длины input.

RegexMatchTimeoutException

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

Примеры

В следующем примере двойные пробелы все, кроме первой строки строки строки. Он определяет шаблон регулярного выражения, ^.*$, соответствующий строке текста, вызывает метод 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).

Заметка

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

замены в регулярных выражениях
язык регулярных выражений — краткий справочник

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

Replace(String, String, String)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

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

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

Параметры

input: String

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

pattern: String

Шаблон регулярного выражения, соответствующий.

replacement: String

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

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

String

Исключения

ArgumentException

Произошла ошибка синтаксического анализа регулярных выражений.

ArgumentNullException

input, patternили replacementnull.

RegexMatchTimeoutException

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

Примеры

В следующем примере определяется регулярное выражение, \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 + "]))`	Выполните нечувствительное сопоставление регистра класса символов, состоящего из отдельных букв дисков. Это совпадение является первым захваченным вложенным выражением.
`\$`	Соответствует знаку литерального доллара (`$`) символу.

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

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

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

Replace(String, String, MatchEvaluator)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

String

Исключения

ArgumentException

Произошла ошибка синтаксического анализа регулярных выражений.

ArgumentNullException

input, patternили evaluatornull.

RegexMatchTimeoutException

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

Примеры

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.Matches(String, String) и передаче каждого объекта Match в возвращенной коллекции MatchCollection делегату evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

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

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

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

Replace(String, String, Int32)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

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

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

Параметры

input: String

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

replacement: String

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

count: Int32

Максимальное количество случаев, когда может произойти замена.

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

String

Исключения

ArgumentNullException

input или replacementnull.

RegexMatchTimeoutException

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

Примеры

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

Заметка

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

язык регулярных выражений — краткий справочник
замены в регулярных выражениях

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

Replace(String, MatchEvaluator)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

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

Параметры

input: String

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

evaluator: MatchEvaluator

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

String

Исключения

ArgumentNullException

input или evaluatornull.

RegexMatchTimeoutException

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

Примеры

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

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.Matches(String) и передаче каждого объекта Match в возвращенной коллекции MatchCollection делегату evaluator.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

MatchEvaluator
замены в регулярных выражениях
язык регулярных выражений — краткий справочник

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

Replace(String, String)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

public string Replace (string input, string replacement);

member this.Replace : string * string -> string

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

Параметры

input: String

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

replacement: String

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

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

String

Исключения

ArgumentNullException

input или replacementnull.

RegexMatchTimeoutException

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

Примеры

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})?`	Если первая записанная группа существует, соответствует пустой строке. В противном случае соответствует нулю или одному символу пробела, за которым следует символ валюты.

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

язык регулярных выражений — краткий справочник
замены в регулярных выражениях

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

Replace(String, MatchEvaluator, Int32)

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

Исходный код:: Regex.Replace.cs

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

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

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

String

Исключения

ArgumentNullException

input или evaluatornull.

RegexMatchTimeoutException

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

Примеры

В следующем примере используется регулярное выражение, чтобы намеренно пропустить половину слов в списке. В нем используется регулярное выражение \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.Matches(String) и передаче первых countMatch объектов в возвращенной коллекции MatchCollection делегату evaluator.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

MatchEvaluator
замены в регулярных выражениях
язык регулярных выражений — краткий справочник

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

Поделиться через

Regex.Replace Метод

Определение

Перегрузки

Replace(String, String, String, RegexOptions)

Параметры

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

Исключения

Примеры

Комментарии

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

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

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

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

Параметры

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

Исключения

Примеры

Комментарии

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

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

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

Replace(String, MatchEvaluator, Int32, Int32)

Параметры

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

Исключения

Комментарии

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

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

Replace(String, String, MatchEvaluator, RegexOptions)

Параметры

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

Исключения

Примеры

Комментарии

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

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

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

Параметры

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

Исключения

Примеры

Комментарии

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

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

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

Replace(String, String, Int32, Int32)

Параметры

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

Исключения

Примеры

Комментарии

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

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

Replace(String, String, String)

Параметры

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

Исключения

Примеры

Комментарии

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

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

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

Replace(String, String, MatchEvaluator)

Параметры

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

Исключения

Примеры

Комментарии

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

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

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

Replace(String, String, Int32)

Параметры

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

Исключения

Примеры

Комментарии

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

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