Regex.Replace メソッド

リファレンス

定義

名前空間:: System.Text.RegularExpressions

アセンブリ:: System.Text.RegularExpressions.dll

アセンブリ:: System.dll

アセンブリ:: netstandard.dll

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

指定した入力文字列内で正規表現パターンに一致する文字列を、指定した置換文字列に置き換えます。

オーバーロード

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)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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 または evaluator が null です。

ArgumentOutOfRangeException

startat が 0 未満か、input の長さを超えています。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

注釈

メソッドは Regex.Replace(String, MatchEvaluator, Int32, Int32) 、次のいずれかの条件に該当する場合に正規表現の一致を置き換える場合に便利です。

置換文字列を正規表現置換パターンで簡単に指定することはできません。
置換文字列は、一致した文字列に対して何らかの処理が行われた結果です。
置換文字列は条件付き処理の結果です。

メソッドは、メソッドをRegex.Matches(String, Int32)呼び出し、返されたMatchCollectionコレクション内の最初countMatchのオブジェクトをデリゲートに渡すことと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例外はスローされません

一致しない場合、メソッドは変更されずに返 input されるため、メソッドを Object.ReferenceEquals 使用して、メソッドが入力文字列に置き換えられたかどうかを判断できます。

こちらもご覧ください

適用対象

Replace(String, String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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

一致する各文字列が置換文字列に置き換えられる以外は入力文字列と同じである新しい文字列。 pattern が現在のインスタンス内で一致しない場合、メソッドは現在のインスタンスを変更せずに返します。

例外

ArgumentException

正規表現の解析エラーが発生しました。

ArgumentNullException

input、pattern、または replacement が null です。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

例

次の例では、 \s+1 つ以上の空白文字に一致する正規表現を定義します。置換文字列 " "は、それらを 1 つのスペース文字に置き換えます。

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 + "]))\$"

次の表に、正規表現パターンがどのように解釈されるかを示します。

パターン	説明
`\\\\`	2 つの連続する円記号 (`\`) 文字と一致します。円記号文字はエスケープ文字として解釈されるため、各円記号は別の円記号でエスケープする必要があります。
`(?i:" + Environment.MachineName + ")`	プロパティによって返される文字列の大文字と小文字を区別しない一致を Environment.MachineName 実行します。
`(?:\.\w+)*`	ピリオド (`.`) 文字の後に 1 つ以上の単語文字を一致させます。この一致は、0 回以上発生する可能性があります。一致する部分式はキャプチャされません。
`\\`	円記号 (`\`) 文字と一致します。
`((?i:[" + driveNames + "]))`	個々のドライブ文字で構成される文字クラスの大文字と小文字を区別しない一致を実行します。この一致は、キャプチャされた最初の部分式です。
`\$`	リテラルドル記号 (`$`) 文字と一致します。

置換パターン $1 は、一致全体を最初にキャプチャされた部分式に置き換えます。つまり、UNC マシンとドライブ名がドライブ文字に置き換えられます。

注釈

静的 Replace メソッドは、指定された正規表現パターンを Regex 使用してオブジェクトを構築し、インスタンスメソッド Replaceを呼び出すことと同じです。

パラメーターは pattern 、一致する文字列をシンボル的に記述する正規表現言語要素で構成されます。正規表現の詳細については、「 .NET 正規表現と正規表現言語 - クイックリファレンス」を参照してください。一致の検索は、文字列の input 先頭から開始されます。

パラメーターは replacement 、の各一致を置き換える文字列を input指定します。 replacement は、リテラルテキストと置換の任意の組み合わせで構成できます。たとえば、置換パターン a*${test}b では、文字列 "a*" の後に、キャプチャグループと test 一致する部分文字列 (存在する場合)、その後に文字列 "b" が挿入されます。 * 文字は、置換パターン内でメタ文字として認識されません。

Note

置換は、置換パターンで認識される唯一の正規表現言語要素です。文字エスケープを含む他のすべての正規表現言語要素は、正規表現パターンでのみ使用でき、置換パターンでは認識されません。

RegexMatchTimeoutException置換操作の実行時間が、メソッドが呼び出されるアプリケーションドメインに指定されたタイムアウト間隔を超えると、例外がスローされます。アプリケーションドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値がの場合、 Regex.InfiniteMatchTimeout例外はスローされません。

注意 (呼び出し元)

このメソッドは、呼び出されるアプリケーションドメインの既定のタイムアウト値と等しい間隔の後にタイムアウトします。アプリケーションドメインにタイムアウト値が定義されていない場合は、メソッドのタイムアウトを妨げる値 InfiniteMatchTimeoutが使用されます。パターン一致を置き換える場合に推奨される静的メソッドは Replace(String, String, String, RegexOptions, TimeSpan)です。これにより、タイムアウト間隔を設定できます。

こちらもご覧ください

適用対象

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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、または evaluator が null です。

ArgumentOutOfRangeException

options は、RegexOptions 値のビットごとの正しい組み合わせではありません。

- または -

matchTimeout が負の値か、0 か、または約 24 日を超えています。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

例

次の例では、正規表現を使用して文字列から個々の単語を抽出し、その単語の個々の文字をスクランブルするという名前WordScrambleのメソッドをデリゲートを使用MatchEvaluatorして呼び出します。これを行うために、メソッドは WordScramble 、一致する文字を含む配列を作成します。また、ランダムな浮動小数点数を入力する並列配列も作成します。配列はメソッドを呼び出 Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) して並べ替えられます。並べ替えられた配列はクラスコンストラクターの String 引数として提供されます。この新しく作成された文字列は、メソッドによって WordScramble 返されます。正規表現パターン \w+ は 1 つ以上の単語文字と一致します。正規表現エンジンは、空白文字などの単語以外の文字が検出されるまで、一致に文字を追加し続けます。メソッドの 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)呼び出し、返されたMatchCollectionコレクション内の各Matchオブジェクトをデリゲートに渡すこととevaluator同じです。

パラメーターは pattern 、一致する文字列をシンボル的に記述する正規表現言語要素で構成されます。正規表現の詳細については、「 .NET 正規表現と正規表現言語 - クイックリファレンス」を参照してください。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

カスタムメソッドは、一致した入力を置き換える文字列を返します。

パラメーターに options を指定RightToLeftすると、一致の検索は入力文字列の末尾から開始され、左に移動します。それ以外の場合は、入力文字列の先頭から検索が開始され、右に移動します。

パラメーターは matchTimeout 、パターンマッチングメソッドがタイムアウトするまでに一致を検索する期間を指定します。タイムアウト間隔を設定すると、過剰なバックトラッキングに依存する正規表現が"近い一致を含む入力を処理するときに応答を停止する" ように見えるのを防ぐことができます。詳細については、「正規表現とバックトラッキングのベストプラクティス」を参照してください。その時間間隔で一致するものが見つからない場合、メソッドは例外を RegexMatchTimeoutException スローします。 matchTimeout は、メソッドが実行されるアプリケーションドメインに対して定義されている既定のタイムアウト値をオーバーライドします。

注意 (呼び出し元)

パラメーターを適切な値 (2 秒など) に設定 matchTimeout することをお勧めします。を指定してタイムアウトを InfiniteMatchTimeout無効にすると、正規表現エンジンのパフォーマンスが若干向上します。ただし、タイムアウトは次の条件でのみ無効にする必要があります。

正規表現によって処理される入力が既知の信頼できるソースから派生した場合、または静的テキストで構成されている場合。これにより、ユーザーによって動的に入力されたテキストが除外されます。
正規表現パターンが十分にテストされ、一致、一致しない、近い一致が効率的に処理されるようにする場合。
正規表現パターンに、近い一致を処理するときに過剰なバックトラッキングを引き起こすことがわかっている言語要素が含まれない場合。

こちらもご覧ください

適用対象

Replace(String, String, MatchEvaluator, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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、または evaluator が null です。

ArgumentOutOfRangeException

options は、RegexOptions 値のビットごとの正しい組み合わせではありません。

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();
      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) 、次のいずれかの条件に該当する場合に、の正規表現の一致を置き換える場合に便利です。

置換文字列を正規表現置換パターンで簡単に指定することはできません。
置換文字列は、一致した文字列に対して何らかの処理が行われた結果です。
置換文字列は条件付き処理の結果です。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

カスタムメソッドは、一致した入力を置き換える文字列を返します。

こちらもご覧ください

適用対象

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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、または replacement が null です。

ArgumentOutOfRangeException

options は、RegexOptions 値のビットごとの正しい組み合わせではありません。

- または -

matchTimeout が負の値か、0 か、または約 24 日を超えています。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

例

次の例では、メソッドを Replace(String, String, String, RegexOptions, TimeSpan) 使用して、UNC パス内のローカルコンピューターとドライブ名をローカルファイルパスに置き換えます。正規表現では、プロパティを Environment.MachineName 使用してローカルコンピューターの名前を含め、メソッドを Environment.GetLogicalDrives 使用して論理ドライブの名前を含めます。すべての正規表現文字列比較では大文字と小文字が区別されず、0.5 秒で一致するものが見つからない場合、1 回の置換操作はタイムアウトします。この例を正常に実行するには、リテラル文字列 "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 + "])\$"

次の表に、正規表現パターンがどのように解釈されるかを示します。

パターン	説明
`\\\\`	2 つの連続する円記号 (`\`) 文字と一致します。円記号文字はエスケープ文字として解釈されるため、各円記号は別の円記号でエスケープする必要があります。
`+ Environment.MachineName +`	プロパティによって返される文字列と Environment.MachineName 一致します。
`(?:\.\w+)*`	ピリオド (`.`) 文字の後に 1 つ以上の単語文字を一致させます。この一致は、0 回以上発生する可能性があります。一致する部分式はキャプチャされません。
`\\`	円記号 (`\`) 文字と一致します。
`([" + driveNames + "])`	個々のドライブ文字で構成される文字クラスと一致します。この一致は、キャプチャされた最初の部分式です。
`\$`	リテラルドル記号 (`$`) 文字と一致します。

注釈

パラメーターは pattern 、一致する文字列をシンボル的に記述する正規表現言語要素で構成されます。正規表現の詳細については、「 .NET 正規表現と正規表現言語 - クイックリファレンス」を参照してください。パラメーターに options を指定RightToLeftすると、一致の検索は入力文字列の末尾から開始され、左に移動します。それ以外の場合は、入力文字列の先頭から検索が開始され、右に移動します。

Note

パラメーターは matchTimeout 、パターンマッチングメソッドがタイムアウトするまでに一致を検索する期間を指定します。タイムアウト間隔を設定すると、過剰なバックトラッキングに依存する正規表現が、近い一致を含む入力を処理するときに応答を停止するように見えなくなります。詳細については、「正規表現とバックトラッキングのベストプラクティス」を参照してください。その時間間隔で一致するものが見つからない場合、メソッドは例外を RegexMatchTimeoutException スローします。 matchTimeout は、メソッドが実行されるアプリケーションドメインに対して定義されている既定のタイムアウト値をオーバーライドします。

注意 (呼び出し元)

正規表現によって処理される入力が既知の信頼できるソースから派生した場合、または静的テキストで構成されている場合。これにより、ユーザーによって動的に入力されたテキストが除外されます。
正規表現パターンが十分にテストされ、一致、一致しない、近い一致が効率的に処理されるようにする場合。
正規表現パターンに、近い一致を処理するときに過剰なバックトラッキングを引き起こすことがわかっている言語要素が含まれない場合。

こちらもご覧ください

適用対象

Replace(String, String, String, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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

例外

ArgumentException

正規表現の解析エラーが発生しました。

ArgumentNullException

input、pattern、または replacement が null です。

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 + "])\$"

次の表に、正規表現パターンがどのように解釈されるかを示します。

パターン	説明
`\\\\`	2 つの連続する円記号 (`\`) 文字と一致します。円記号文字はエスケープ文字として解釈されるため、各円記号は別の円記号でエスケープする必要があります。
`+ Environment.MachineName +`	プロパティによって返される文字列と Environment.MachineName 一致します。
`(?:\.\w+)*`	ピリオド (`.`) 文字の後に 1 つ以上の単語文字を一致させます。この一致は、0 回以上発生する可能性があります。一致する部分式はキャプチャされません。
`\\`	円記号 (`\`) 文字と一致します。
`([" + driveNames + "])`	個々のドライブ文字で構成される文字クラスと一致します。この一致は、キャプチャされた最初の部分式です。
`\$`	リテラルドル記号 (`$`) 文字と一致します。

注釈

Note

注意 (呼び出し元)

こちらもご覧ください

適用対象

Replace(String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

指定した入力文字列内で、指定した正規表現に一致するすべての文字列を 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

各一致文字列を調べ、元の一致文字列または置換文字列のどちらかを返すカスタムメソッド。

戻り値

String

例外

ArgumentNullException

input または evaluator が null です。

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.Replace(String, MatchEvaluator) 、次のいずれかの条件に該当する場合に正規表現の一致を置き換える場合に便利です。

置換文字列を正規表現置換パターンで簡単に指定することはできません。
置換文字列は、一致した文字列に対して何らかの処理が行われた結果です。
置換文字列は条件付き処理の結果です。

メソッドは、メソッドをRegex.Matches(String)呼び出し、返されたMatchCollectionコレクション内の各Matchオブジェクトをデリゲートに渡すこととevaluator同じです。

正規表現は、現在 Regex のオブジェクトのコンストラクターによって定義されるパターンです。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

カスタムメソッドは、一致した入力を置き換える文字列を返します。

こちらもご覧ください

適用対象

Replace(String, MatchEvaluator, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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 または evaluator が null です。

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*`	0 個以上の単語に使用される文字に一致します。
`(ie\|ei)`	"ie" または "ei" のいずれかと一致します。
`\w*`	0 個以上の単語に使用される文字に一致します。

メソッドのReverseLetter正規表現パターン([ie])([ie])は、diphthong "ie" または "ei" の最初の "i" または "e" と一致し、最初のキャプチャグループに文字を割り当てます。 2 番目の "i" または "e" と一致し、2 番目のキャプチャグループに文字を割り当てます。次に、置換パターン $2$1を使用してメソッドをReplace(String, String, String)呼び出すことによって、2 つの文字が逆になります。

注釈

メソッドは Regex.Replace(String, MatchEvaluator, Int32) 、次のいずれかの条件に該当する場合に正規表現の一致を置き換える場合に便利です。

置換文字列を正規表現置換パターンで簡単に指定することはできません。
置換文字列は、一致した文字列に対して何らかの処理が行われた結果です。
置換文字列は条件付き処理の結果です。

メソッドは、メソッドをRegex.Matches(String)呼び出し、返されたMatchCollectionコレクション内の最初countMatchのオブジェクトをデリゲートに渡すこととevaluator同じです。

正規表現は、現在 Regex のオブジェクトのコンストラクターによって定義されるパターンです。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

カスタムメソッドは、一致した入力を置き換える文字列を返します。

こちらもご覧ください

適用対象

Replace(String, String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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、または evaluator が null です。

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.Replace(String, String, MatchEvaluator) 、次のいずれかの条件に該当する場合に正規表現の一致を置き換える場合に便利です。

置換文字列を正規表現置換パターンで簡単に指定することはできません。
置換文字列は、一致した文字列に対して何らかの処理が行われた結果です。
置換文字列は条件付き処理の結果です。

メソッドは、メソッドをRegex.Matches(String, String)呼び出し、返されたMatchCollectionコレクション内の各Matchオブジェクトをデリゲートに渡すことと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)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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 または replacement が null です。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

例

次の例では、重複した文字の最初の 5 回を 1 文字に置き換えます。正規表現パターン (\w)\1 は、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" が挿入されます。 * 文字は、置換パターン内でメタ文字として認識されません。

Note

こちらもご覧ください

適用対象

Replace(String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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 または replacement が null です。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

例

次の例では、 \s+1 つ以上の空白文字に一致する正規表現を定義します。置換文字列 " "は、それらを 1 つのスペース文字に置き換えます。

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'

この正規表現の解釈を次の表に示します。

Pattern	説明
`\p{Sc}`	通貨記号と一致します。 `{Sc}` は、Unicode 記号、通貨カテゴリのメンバーである任意の文字を示します。
`\s?`	0 個または 1 個の空白文字と一致します。
`(\p{Sc}\s?)?`	通貨記号の組み合わせの 0 または 1 回の出現と一致し、その後に 0 または 1 個の空白文字が続きます。これが最初のキャプチャグループです。
`\d+`	1 個以上の 10 進数と一致します。
`\.?`	ピリオドの 0 回または 1 回の出現と一致します (小数点区切り文字として使用されます)。
`((?<=\.)\d+)?`	ピリオドが前の文字の場合は、1 つ以上の 10 進数と一致します。このパターンは、0 回または 1 回に一致させることができます。
`(\d+\.?((?<=\.)\d+)?)`	1 つ以上の 10 進数のパターンに一致し、その後に省略可能なピリオドと 10 進数を追加します。これが 2 番目のキャプチャグループです。メソッドの Replace(String, String) 呼び出しによって、一致全体がこのキャプチャされたグループの値に置き換えられます。
`(?(1)\|\s?\p{Sc})?`	最初にキャプチャされたグループが存在する場合は、空の文字列と一致します。それ以外の場合は、0 個または 1 個の空白文字の後に通貨記号が続きます。

注釈

一致の検索は、文字列の input 先頭から開始されます。正規表現は、現在 Regex のオブジェクトのコンストラクターによって定義されるパターンです。

Note

こちらもご覧ください

適用対象

Replace(String, String, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: 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 または replacement が null です。

ArgumentOutOfRangeException

startat が 0 未満か、input の長さを超えています。

RegexMatchTimeoutException

タイムアウトが発生しました。タイムアウトの詳細については、「解説」をご覧ください。

例

次の例では、文字列の最初の行以外のすべてのスペースを 2 行に設定します。テキスト行に一致する正規表現パターンを定義し、 ^.*$メソッドをMatch(String)呼び出して文字列の最初の行に一致し、プロパティと Match.Count プロパティを使用Match.Indexして 2 行目の開始位置を決定します。

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 してインスタンス化されていることに注意してください。それ以外の場合、この文字クラスは入力文字列の先頭にのみ一致します)。
`.*`	0 回以上の任意の文字に一致します。
`$`	行の末尾と一致します。 (オブジェクトはオプションを Regex 使用 RegexOptions.Multiline してインスタンス化されていることに注意してください。それ以外の場合、この文字クラスは入力文字列の先頭にのみ一致します)。

置換文字列 (vbCrLf + "$&" Visual Basic の C# では ) は、 "\n$&" 一致する文字列の前に新しい行を追加します。 \n C# の例では、C# コンパイラによって改行文字として解釈されます。正規表現文字エスケープは表しません。

注釈

一致の検索は、パラメーターで input 指定された位置にある文字列から startat 開始されます。正規表現は、現在 Regex のオブジェクトのコンストラクターによって定義されるパターンです。が負の場合 count 、置換は文字列の末尾まで続きます。一致の数を超える場合 count は、すべての一致が置き換えられます。

の詳細 startatについては、の「解説」セクション Match(String, Int32)を参照してください。

パラメーターは replacement 、の各一致を置き換える文字列を input指定します。 replacement は、リテラルテキストと置換の任意の組み合わせで構成できます。たとえば、置換パターン a*${test}b では、文字列 "a*" の後に、キャプチャグループで test 一致する部分文字列 (存在する場合) と文字列 "b" が挿入されます。 * 文字は、置換パターン内でメタ文字として認識されません。

Note

こちらもご覧ください

適用対象