Regex.Replace メソッド

定義

名前空間:

System.Text.RegularExpressions

アセンブリ:

System.Text.RegularExpressions.dll

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

オーバーロード

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)

ソース:

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

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

置換操作の実行時間が、Regex.Regex(String, RegexOptions, TimeSpan) コンストラクターで指定されたタイムアウト間隔を超えると、RegexMatchTimeoutException 例外がスローされます。 コンストラクターを呼び出すときにタイムアウト間隔を設定しない場合、Regex オブジェクトが作成されるアプリケーション ドメインに対して確立されたタイムアウト値を操作が超えた場合、例外がスローされます。 Regex コンストラクター呼び出しまたはアプリケーション ドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値が Regex.InfiniteMatchTimeout場合、例外はスローされません

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

こちらもご覧ください

• MatchEvaluator
• 正規表現 での置換の
• 正規表現言語 - クイック リファレンス

Replace(String, String, String)

ソース:

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

タイムアウトが発生しました。 タイムアウトの詳細については、「解説」セクションを参照してください。

例

次の例では、1 つ以上の空白文字に一致する正規表現 (\s+) を定義します。 置換文字列 " "は、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" を挿入します。 * 文字は、置換パターン内でメタ文字として認識されません。

手記

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

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

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

注意 (呼び出し元)

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

こちらもご覧ください

• 正規表現 での置換の
• 正規表現言語要素 を する

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

ソース:

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

置換文字列が一致した各文字列の代わりに使用されることを除き、入力文字列と同じ新しい文字列。 pattern が現在のインスタンスで一致しない場合、メソッドは現在のインスタンスを変更せずに返します。

例外

ArgumentException

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

ArgumentNullException

input、pattern、または evaluator が null。

ArgumentOutOfRangeException

options は、RegexOptions 値の有効なビットごとの組み合わせではありません。

-又は-

matchTimeout が負、ゼロ、または約 24 日を超えています。

RegexMatchTimeoutException

タイムアウトが発生しました。 タイムアウトの詳細については、「解説」セクションを参照してください。

例

次の例では、正規表現を使用して文字列から個々の単語を抽出し、MatchEvaluator デリゲートを使用して、単語内の個々の文字をスクランブリングする WordScramble という名前のメソッドを呼び出します。 これを行うために、WordScramble メソッドは、一致する文字を含む配列を作成します。 また、ランダムな浮動小数点数を設定する並列配列も作成されます。 配列は、Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) メソッドを呼び出すことによって並べ替えられます。並べ替えられた配列は、String クラス コンストラクターの引数として提供されます。 この新しく作成された文字列は、WordScramble メソッドによって返されます。 正規表現パターン \w+ は、1 つ以上の単語文字と一致します。正規表現エンジンは、空白文字などの単語以外の文字が検出されるまで、一致に文字を追加し続けます。 Replace(String, String, MatchEvaluator, RegexOptions) メソッドの呼び出しには、正規表現パターン \w+ # Matches all the characters in a word. のコメントが正規表現エンジンによって無視されるように、RegexOptions.IgnorePatternWhitespace オプションが含まれています。

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 正規表現 と 正規表現言語 - クイック リファレンス」を参照してください。

evaluator パラメーターは、定義し、各一致を調べるカスタム メソッドのデリゲートです。 カスタム メソッドには、MatchEvaluator デリゲートと一致する次のシグネチャが必要です。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

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

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

注意 (呼び出し元)

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

• 正規表現によって処理される入力が既知の信頼できるソースから派生した場合、または静的テキストで構成されている場合。 これにより、ユーザーによって動的に入力されたテキストが除外されます。

• 正規表現パターンが十分にテストされ、一致、一致しない、および近い一致が効率的に処理されるようにする場合。

• 正規表現パターンに、近い一致を処理するときに過剰なバックトラッキングを引き起こすことがわかっている言語要素が含まれている場合。

こちらもご覧ください

• RegexOptions
• 正規表現 での置換の
• 正規表現言語要素 を する
• 正規表現 でのバックトラッキングの
• .NET での正規表現のベスト プラクティス

Replace(String, String, MatchEvaluator, RegexOptions)

ソース:

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

置換文字列が一致した各文字列の代わりに使用されることを除き、入力文字列と同じ新しい文字列。 pattern が現在のインスタンスで一致しない場合、メソッドは現在のインスタンスを変更せずに返します。

例外

ArgumentException

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

ArgumentNullException

input、pattern、または evaluator が null。

ArgumentOutOfRangeException

options は、RegexOptions 値の有効なビットごとの組み合わせではありません。

RegexMatchTimeoutException

タイムアウトが発生しました。 タイムアウトの詳細については、「解説」セクションを参照してください。

例

次の例では、正規表現を使用して文字列から個々の単語を抽出し、MatchEvaluator デリゲートを使用して、単語内の個々の文字をスクランブリングする WordScramble という名前のメソッドを呼び出します。 これを行うために、WordScramble メソッドは、一致する文字を含む配列を作成します。 また、ランダムな浮動小数点数を設定する並列配列も作成されます。 配列は、Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) メソッドを呼び出すことによって並べ替えられます。並べ替えられた配列は、String クラス コンストラクターの引数として提供されます。 この新しく作成された文字列は、WordScramble メソッドによって返されます。 正規表現パターン \w+ は、1 つ以上の単語文字と一致します。正規表現エンジンは、空白文字などの単語以外の文字が検出されるまで、一致に文字を追加し続けます。 Replace(String, String, MatchEvaluator, RegexOptions) メソッドの呼び出しには、正規表現パターン \w+ # Matches all the characters in a word. のコメントが正規表現エンジンによって無視されるように、RegexOptions.IgnorePatternWhitespace オプションが含まれています。

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

注釈

Regex.Replace(String, String, MatchEvaluator, RegexOptions) メソッドは、次のいずれかの条件が当てはまる場合に正規表現の一致を置き換える場合に役立ちます。

• 置換文字列は、正規表現の置換パターンでは簡単に指定できません。

• 置換文字列は、一致した文字列に対して何らかの処理が行われた結果です。

• 置換文字列は条件付き処理の結果です。

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

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

evaluator パラメーターは、定義し、各一致を調べるカスタム メソッドのデリゲートです。 カスタム メソッドには、MatchEvaluator デリゲートと一致する次のシグネチャが必要です。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

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

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

こちらもご覧ください

• MatchEvaluator
• RegexOptions
• 正規表現 での置換の
• 正規表現言語要素 を する

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

ソース:

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

置換文字列が一致した各文字列の代わりに使用されることを除き、入力文字列と同じ新しい文字列。 pattern が現在のインスタンスで一致しない場合、メソッドは現在のインスタンスを変更せずに返します。

例外

ArgumentException

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

ArgumentNullException

input、pattern、または replacement が null。

ArgumentOutOfRangeException

options は、RegexOptions 値の有効なビットごとの組み合わせではありません。

-又は-

matchTimeout が負、ゼロ、または約 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 + "])	個々のドライブ文字で構成される文字クラスと一致します。 この一致は、キャプチャされた最初の部分式です。
\$	リテラルドル記号 ($) 文字と一致します。

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

注釈

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

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

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

手記

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

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

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

注意 (呼び出し元)

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

• 正規表現によって処理される入力が既知の信頼できるソースから派生した場合、または静的テキストで構成されている場合。 これにより、ユーザーによって動的に入力されたテキストが除外されます。

• 正規表現パターンが十分にテストされ、一致、一致しない、および近い一致が効率的に処理されるようにする場合。

• 正規表現パターンに、近い一致を処理するときに過剰なバックトラッキングを引き起こすことがわかっている言語要素が含まれている場合。

こちらもご覧ください

• RegexOptions
• 正規表現 での置換の
• 正規表現言語要素 を する
• 正規表現 でのバックトラッキングの
• .NET での正規表現のベスト プラクティス

Replace(String, String, String, RegexOptions)

ソース:

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、または 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 + "])	個々のドライブ文字で構成される文字クラスと一致します。 この一致は、キャプチャされた最初の部分式です。
\$	リテラルドル記号 ($) 文字と一致します。

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

注釈

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

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

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

手記

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

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

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

注意 (呼び出し元)

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

こちらもご覧ください

• RegexOptions
• 正規表現 での置換の
• 正規表現言語要素 を する

Replace(String, MatchEvaluator)

ソース:

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 オブジェクトのコンストラクターによって定義されるパターンです。

evaluator パラメーターは、定義し、各一致を調べるカスタム メソッドのデリゲートです。 カスタム メソッドには、MatchEvaluator デリゲートと一致する次のシグネチャが必要です。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

置換操作の実行時間が、Regex.Regex(String, RegexOptions, TimeSpan) コンストラクターで指定されたタイムアウト間隔を超えると、RegexMatchTimeoutException 例外がスローされます。 コンストラクターを呼び出すときにタイムアウト間隔を設定しない場合、Regex オブジェクトが作成されるアプリケーション ドメインに対して確立されたタイムアウト値を操作が超えた場合、例外がスローされます。 Regex コンストラクター呼び出しまたはアプリケーション ドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値が Regex.InfiniteMatchTimeout場合、例外はスローされません

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

こちらもご覧ください

• MatchEvaluator
• 正規表現 での置換の
• 正規表現言語 - クイック リファレンス

Replace(String, MatchEvaluator, Int32)

ソース:

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 オブジェクトのコンストラクターによって定義されるパターンです。

evaluator パラメーターは、定義し、各一致を調べるカスタム メソッドのデリゲートです。 カスタム メソッドには、MatchEvaluator デリゲートと一致する次のシグネチャが必要です。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

置換操作の実行時間が、Regex.Regex(String, RegexOptions, TimeSpan) コンストラクターで指定されたタイムアウト間隔を超えると、RegexMatchTimeoutException 例外がスローされます。 コンストラクターを呼び出すときにタイムアウト間隔を設定しない場合、Regex オブジェクトが作成されるアプリケーション ドメインに対して確立されたタイムアウト値を操作が超えた場合、例外がスローされます。 Regex コンストラクター呼び出しまたはアプリケーション ドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値が Regex.InfiniteMatchTimeout場合、例外はスローされません

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

こちらもご覧ください

• MatchEvaluator
• 正規表現 での置換の
• 正規表現言語 - クイック リファレンス

Replace(String, String, MatchEvaluator)

ソース:

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

置換文字列が一致した各文字列の代わりに使用されることを除き、入力文字列と同じ新しい文字列。 pattern が現在のインスタンスで一致しない場合、メソッドは現在のインスタンスを変更せずに返します。

例外

ArgumentException

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

ArgumentNullException

input、pattern、または evaluator が null。

RegexMatchTimeoutException

タイムアウトが発生しました。 タイムアウトの詳細については、「解説」セクションを参照してください。

例

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

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 デリゲートに渡すことと同じです。

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

evaluator パラメーターは、定義し、各一致を調べるカスタム メソッドのデリゲートです。 カスタム メソッドには、MatchEvaluator デリゲートと一致する次のシグネチャが必要です。

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

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

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

注意 (呼び出し元)

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

こちらもご覧ください

• MatchEvaluator
• 正規表現 での置換の
• 正規表現言語要素 を する

Replace(String, String, Int32)

ソース:

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

手記

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

置換操作の実行時間が、Regex.Regex(String, RegexOptions, TimeSpan) コンストラクターで指定されたタイムアウト間隔を超えると、RegexMatchTimeoutException 例外がスローされます。 コンストラクターを呼び出すときにタイムアウト間隔を設定しない場合、Regex オブジェクトが作成されるアプリケーション ドメインに対して確立されたタイムアウト値を操作が超えた場合、例外がスローされます。 Regex コンストラクター呼び出しまたはアプリケーション ドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値が Regex.InfiniteMatchTimeout場合、例外はスローされません

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

こちらもご覧ください

• 正規表現言語 - クイック リファレンス
• 正規表現 での置換の

Replace(String, String)

ソース:

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

タイムアウトが発生しました。 タイムアウトの詳細については、「解説」セクションを参照してください。

例

次の例では、1 つ以上の空白文字に一致する正規表現 (\s+) を定義します。 置換文字列 " "は、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'

正規表現は、次の表に示すように解釈されます。

パターン	形容
\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 オブジェクトのコンストラクターによって定義されるパターンです。

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

手記

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

置換操作の実行時間が、Regex.Regex(String, RegexOptions, TimeSpan) コンストラクターで指定されたタイムアウト間隔を超えると、RegexMatchTimeoutException 例外がスローされます。 コンストラクターを呼び出すときにタイムアウト間隔を設定しない場合、Regex オブジェクトが作成されるアプリケーション ドメインに対して確立されたタイムアウト値を操作が超えた場合、例外がスローされます。 Regex コンストラクター呼び出しまたはアプリケーション ドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値が Regex.InfiniteMatchTimeout場合、例外はスローされません

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

こちらもご覧ください

• 正規表現言語 - クイック リファレンス
• 正規表現 での置換の

Replace(String, String, Int32, Int32)

ソース:

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.Index プロパティと Match.Count プロパティを使用して 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 オプションを使用してインスタンス化されていることに注意してください。それ以外の場合、この文字クラスは入力文字列の先頭にのみ一致します)。

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

注釈

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

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

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

手記

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

置換操作の実行時間が、Regex.Regex(String, RegexOptions, TimeSpan) コンストラクターで指定されたタイムアウト間隔を超えると、RegexMatchTimeoutException 例外がスローされます。 コンストラクターを呼び出すときにタイムアウト間隔を設定しない場合、Regex オブジェクトが作成されるアプリケーション ドメインに対して確立されたタイムアウト値を操作が超えた場合、例外がスローされます。 Regex コンストラクター呼び出しまたはアプリケーション ドメインのプロパティでタイムアウトが定義されていない場合、またはタイムアウト値が Regex.InfiniteMatchTimeout場合、例外はスローされません

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

こちらもご覧ください

• 正規表現 での置換の
• 正規表現言語 - クイック リファレンス