---

C#における文字列置換：完全ガイド – 基本から応用、パフォーマンスまで

はじめに

文字列は、プログラミングにおいて最も基本的かつ頻繁に扱われるデータ型の一つです。テキストの表示、データの解析、ユーザー入力の処理など、様々な場面で文字列操作が必要となります。その中でも「置換（Replace）」は、特定の文字列やパターンを別の文字列に置き換えるという、非常に重要な操作です。

C#には、この文字列置換を実現するための複数の方法が用意されています。最も基本的な string.Replace メソッドから、効率的な StringBuilder.Replace、そして高度なパターンマッチングを可能にする正規表現（Regex.Replace）まで、それぞれに特徴があり、適切な使い分けが必要です。

この記事では、C#における文字列置換の様々な手法について、その基本的な使い方から、内部的な挙動、パフォーマンスに関する考慮事項、そして実践的な応用例までを網羅的に解説します。この記事を読むことで、あなたのC#プログラムにおける文字列置換が、より効率的かつ目的に合ったものになることを目指します。

C#における文字列の特性：Immutable (不変) 性

文字列置換について深く理解する上で、C#の文字列（string型）が「immutable（不変）」であるという特性を理解しておくことは非常に重要です。

不変性とは、一度作成された文字列オブジェクトの内容は、後から変更することができないという性質です。例えば、string str = "Hello"; という文字列を作成した後、str.Replace("H", "J") のような操作を行っても、元の str オブジェクト自身が “Jello” に変更されるわけではありません。代わりに、"Jello" という新しい文字列オブジェクトがメモリ上に生成され、Replace メソッドはその新しいオブジェクトを返します。

“`csharp
string original = “Hello World”;
string replaced = original.Replace(“World”, “C#”);

// original の内容は変わらない
Console.WriteLine($”Original: {original}”); // 出力: Original: Hello World
// replaced は新しい文字列オブジェクトを参照する
Console.WriteLine($”Replaced: {replaced}”); // 出力: Replaced: Hello C#

// これを理解せずに str = str.Replace(…) と書くと、
// 見た目は元の変数strが変更されたように見えるが、
// 実際には新しいオブジェクトをstrが参照し直しているだけである。
string s = “apple”;
Console.WriteLine($”Before replace: {s}”); // 出力: Before replace: apple
s = s.Replace(“a”, “A”); // 新しい “Apple” オブジェクトが作られ、sがそれを参照する
Console.WriteLine($”After replace: {s}”); // 出力: After replace: Apple

// この新しいオブジェクト生成のメカニズムが、パフォーマンスに影響を与える場合がある。
“`

この不変性のため、文字列に対して繰り返し置換などの操作を行うと、その都度新しい文字列オブジェクトが生成されます。生成と破棄（ガベージコレクション）のオーバーヘッドが積み重なり、特に大量の文字列操作を行う場合や、ループ内で頻繁に置換を行うような場合には、パフォーマンス上の問題を引き起こす可能性があります。

文字列の不変性は、スレッドセーフである、ハッシュコードが固定されるなどのメリットもありますが、頻繁な内容変更を伴う操作においては、この特性を考慮した別の手法（例えば StringBuilder）を選択する必要があります。

1. 基本的な文字列置換: string.Replace() メソッド

C#で最も手軽に文字列置換を行う方法が、string クラスが提供する Replace() メソッドを利用することです。

string.Replace() メソッドにはいくつかのオーバーロードがありますが、主に以下の2つがよく使われます。

1. string Replace(char oldChar, char newChar): 指定した1文字を別の1文字に置換します。
2. string Replace(string oldValue, string newValue): 指定した文字列（サブストリング）を別の文字列に置換します。

これらのメソッドは、元の文字列中の全ての一致する部分を置換します。そして、前述の通り、置換結果を含む新しい文字列オブジェクトを返します。

1.1. Replace(char, char) の使い方

単一の文字を別の単一の文字に置換する場合に使用します。

“`csharp
string text = “banana”;
// ‘a’ を ‘‘ に置換する
string replacedText = text.Replace(‘a’, ‘‘);

Console.WriteLine($”Original: {text}”); // 出力: Original: banana
Console.WriteLine($”Replaced: {replacedText}”); // 出力: Replaced: bnn*
“`

このメソッドはシンプルで高速ですが、1対1の文字置換にしか使えません。

1.2. Replace(string, string) の使い方

特定の文字列（サブストリング）を別の文字列に置換する場合に最も一般的に使用されます。

“`csharp
string sentence = “Hello world, hello C#!”;
// “hello” を “hi” に置換する
string replacedSentence = sentence.Replace(“hello”, “hi”);

Console.WriteLine($”Original: {sentence}”); // 出力: Original: Hello world, hello C#!
Console.WriteLine($”Replaced: {replacedSentence}”); // 出力: Replaced: Hello world, hi C#!
“`

注意点:

• Replace(string, string) は大文字・小文字を区別します。上の例では、最初の “Hello” は “hello” と完全に一致しないため置換されず、2番目の “hello” のみが置換されています。
• 置換対象の文字列 (oldValue) が見つからない場合、元の文字列がそのまま返されます（新しいオブジェクトが生成されるわけではない場合が多いですが、元の参照がそのまま返されます）。
• 置換対象の文字列 (oldValue) に空文字列 ("") を指定すると、newValue が元の文字列の各文字の間に挿入されます。これはあまり一般的ではありませんが、特殊なケースで利用できます。

csharp
string data = "123";
string inserted = data.Replace("", "-");
Console.WriteLine(inserted); // 出力: -1-2-3-

• 置換後の文字列 (newValue) に空文字列 ("") を指定すると、置換対象の文字列が削除されます。

csharp
string path = "/usr/local/bin";
// "/local" を削除する
string cleanedPath = path.Replace("/local", "");
Console.WriteLine(cleanedPath); // 出力: /usr/bin

1.3. 複数の置換を行う場合

string.Replace は一度に一つの置換しか行えません。複数の異なる置換を行いたい場合は、Replace メソッドをチェーン（連結）して呼び出すか、ループで処理する必要があります。

チェーンによる置換:

“`csharp
string messyString = ” Hello World! “;
// 先頭と末尾の空白をトリムし、複数の空白を一つにし、感嘆符をピリオドに置換
string cleanedString = messyString
.Trim() // “Hello World!”
.Replace(” “, ” “) // “Hello World!” – まだ複数の空白が残る可能性がある
.Replace(” “, ” “) // “Hello World!” – 繰り返し適用する必要がある場合がある
.Replace(“!”, “.”); // “Hello World.”

Console.WriteLine($”Original: ‘{messyString}'”); // 出力: Original: ‘ Hello World! ‘
Console.WriteLine($”Cleaned: ‘{cleanedString}'”); // 出力: Cleaned: ‘Hello World.’

// 注意: 複数の空白を一つにするような操作は、単純なReplaceのチェーンでは難しい場合が多い。
// 例えば “a b” に対して Replace(” “, ” “) を2回適用する必要がある。
// このようなケースでは、正規表現を使う方が効率的で正確。
“`

チェーンによる置換は、数回程度の単純な置換であればコードが簡潔になります。しかし、置換の回数が多かったり、置換ルールが複雑だったりすると、コードが読みにくくなり、またパフォーマンス上の懸念が出てきます。なぜなら、チェーンの各ステップで新しい文字列オブジェクトが生成されるからです。

string.Replace は、置換対象や置換後の文字列が短い場合や、置換回数が少ない場合には、シンプルで分かりやすく、十分なパフォーマンスを発揮します。しかし、文字列が長かったり、置換回数が多かったりするシナリオでは、次に説明する StringBuilder や Regex を検討する必要があります。

1.4. カルチャを考慮したReplace (.NET 5以降)

.NET 5以降では、string.Replace(string oldValue, string newValue, StringComparison comparisonType) という新しいオーバーロードが追加されました。これにより、大文字/小文字の区別やカルチャを考慮した文字列比較を指定して置換を行うことが可能になりました。

StringComparison 列挙体を使用して、比較方法を指定します。よく使われる値としては以下のものがあります。

• Ordinal: 大文字/小文字やカルチャを無視した、バイナリ値による厳密な比較。最も高速で予測可能。
• OrdinalIgnoreCase: カルチャを無視し、大文字/小文字を区別しないバイナリ比較。
• CurrentCulture: 現在のスレッドのカルチャ規則に基づいた比較。言語に依存する比較（例: トルコ語の ‘I’ と ‘i’ の関係）。
• CurrentCultureIgnoreCase: 現在のカルチャ規則に基づき、大文字/小文字を区別しない比較。
• InvariantCulture: インバリアントカルチャ（言語・地域に依存しないカルチャ）に基づいた比較。
• InvariantCultureIgnoreCase: インバリアントカルチャに基づき、大文字/小文字を区別しない比較。

“`csharp
string greeting = “Hello WORLD”;
// 大文字/小文字を区別せずに “world” を “everyone” に置換 (.NET 5以降)

if NET5_0_OR_GREATER

string replacedGreeting = greeting.Replace(“WORLD”, “everyone”, StringComparison.OrdinalIgnoreCase);
Console.WriteLine($”Case-insensitive replace: {replacedGreeting}”); // 出力: Case-insensitive replace: Hello everyone

else

// .NET Framework や .NET Core 3.1 以前では、正規表現やToLower/ToUpperなどでの回避が必要
Console.WriteLine(“Case-insensitive replace is not directly supported by string.Replace in this .NET version.”);

endif

// Note: string.Replace に StringComparison.CurrentCulture や InvariantCulture を指定すると、
// 文字列の比較だけでなく、置換自体もそのカルチャのルールに従って行われる。
// 例えば、ドイツ語の ‘ß’ を ‘SS’ に置換するなど、特定のカルチャにおける特殊な文字のマッピングが考慮される可能性がある。
“`

特定のカルチャに基づいた比較や、大文字/小文字を区別しない置換が必要な場合は、このオーバーロードが非常に便利です。ただし、.NET 5以降でのみ利用可能です。古いバージョンの.NETを使用している場合は、正規表現 (Regex) を使用するか、対象文字列を事前に ToLower() または ToUpper() で変換してから Replace を行うなどの回避策が必要になります。

2. 複数の置換を効率的に行う: StringBuilder.Replace()

string.Replace() を繰り返し呼び出すことによる新しいオブジェクトの頻繁な生成は、特に大量の文字列を処理する場合や、一つの文字列に対して多数の置換を行う場合に、パフォーマンスのボトルネックとなる可能性があります。

このようなシナリオで活躍するのが System.Text.StringBuilder クラスです。StringBuilder は、内部的に文字のバッファを持ち、文字列の内容を「可変（mutable）」に扱うことができます。これにより、文字列を変更する際に新しいオブジェクトを生成するオーバーヘッドを大幅に削減できます。

StringBuilder クラスにも Replace() メソッドが用意されており、string.Replace() と同様の機能を提供しますが、操作対象は StringBuilder オブジェクト自身であり、結果として新しい StringBuilder オブジェクトを返すのではなく、元のオブジェクトの内容を変更します。

2.1. StringBuilder の基本

StringBuilder を使用する一般的な流れは以下の通りです。

1. StringBuilder オブジェクトを作成し、初期文字列（または空）を指定します。
2. Append, Insert, Remove, Replace などのメソッドを使用して、文字列の内容を効率的に変更します。
3. 最後に、ToString() メソッドを呼び出して、構築した文字列を string オブジェクトとして取得します。

“`csharp
using System.Text;

// StringBuilderの作成
StringBuilder sb = new StringBuilder(“Initial text.”);
Console.WriteLine($”Initial: {sb}”); // 出力: Initial: Initial text.

// 内容の変更（元のオブジェクトが変更される）
sb.Append(” Added text.”);
sb.Insert(0, “Prefix: “);
sb.Remove(sb.Length – 1, 1); // 末尾のピリオドを削除

Console.WriteLine($”Modified: {sb}”); // 出力: Modified: Prefix: Initial text Added text

// stringオブジェクトとして取得
string finalString = sb.ToString();
Console.WriteLine($”Final string: {finalString}”); // 出力: Final string: Prefix: Initial text Added text
“`

2.2. StringBuilder.Replace() の使い方

StringBuilder.Replace() メソッドには、主に以下のオーバーロードがあります。

1. StringBuilder Replace(char oldChar, char newChar): 文字の置換
2. StringBuilder Replace(string oldValue, string newValue): 文字列の置換
3. StringBuilder Replace(char oldChar, char newChar, int startIndex, int count): 指定範囲内の文字置換
4. StringBuilder Replace(string oldValue, string newValue, int startIndex, int count): 指定範囲内の文字列置換

string.Replace() と同様に、一致する全ての部分を置換します。引数に startIndex と count を指定することで、置換を適用する範囲を限定することも可能です。

“`csharp
using System.Text;

string originalString = “This is a test string. This string is for testing.”;
StringBuilder sb = new StringBuilder(originalString);

// 全ての “is” を “was” に置換
sb.Replace(“is”, “was”);
Console.WriteLine($”After replace ‘is’->’was’: {sb}”); // 出力: After replace ‘is’->’was’: Thwas was a test string. Thwas string was for testing.

// 範囲指定での置換 (最初の “Thwas” を “This” に戻す)
// インデックス 0 から 4 文字の範囲で “Thwas” を “This” に置換
sb.Replace(“Thwas”, “This”, 0, 5); // “Thwas” は5文字なので範囲も5
Console.WriteLine($”Range replace: {sb}”); // 出力: Range replace: This was a test string. Thwas string was for testing.
“`

2.3. StringBuilder.Replace() の利点

• 効率性: 頻繁な内容変更（特に置換）において、新しい string オブジェクトの生成オーバーヘッドがないため、string.Replace を繰り返すよりもはるかに高速です。
• メモリ使用量: 多くの新しい string オブジェクトが生成されないため、ガベージコレクションの負荷が軽減され、メモリ効率が良くなります。

2.4. StringBuilder.Replace() の適用シナリオ

• ファイルから読み込んだ巨大なテキストデータに対して複数の置換処理を適用する場合。
• ループ内で動的に文字列を構築し、その中で条件に応じた置換を行う場合。
• テンプレート文字列内の複数のプレースホルダーを実際の値に置き換える場合（ただし、多数の異なるプレースホルダーがある場合は、後述する正規表現がより適していることもあります）。

例えば、多数の単語を別の単語に置換する処理を考えます。

“`csharp
using System.Text;
using System.Collections.Generic;

string longText = “apple banana apple cherry banana apple date”;
Dictionary replacements = new Dictionary
{
{ “apple”, “orange” },
{ “banana”, “grape” },
{ “cherry”, “strawberry” }
};

// string.Replaceを繰り返す場合 (非効率な可能性)
string resultString = longText;
foreach (var pair in replacements)
{
resultString = resultString.Replace(pair.Key, pair.Value);
}
Console.WriteLine($”Using string.Replace repeatedly: {resultString}”); // 出力: Using string.Replace repeatedly: orange grape orange strawberry grape orange date

// StringBuilder.Replaceを使用する場合 (効率的)
StringBuilder sbEfficient = new StringBuilder(longText);
foreach (var pair in replacements)
{
sbEfficient.Replace(pair.Key, pair.Value);
}
string resultStringBuilder = sbEfficient.ToString();
Console.WriteLine($”Using StringBuilder.Replace: {resultStringBuilder}”); // 出力: Using StringBuilder.Replace: orange grape orange strawberry grape orange date
“`

置換対象の数や文字列の長さ、置換回数が増えるほど、StringBuilder を使用した場合のパフォーマンス上のメリットが顕著になります。ただし、StringBuilder の初期化や ToString() の呼び出しにもある程度のコストがかかるため、ごく少数の置換であれば string.Replace の方が簡潔で高速な場合もあります。

3. 高度な文字列置換: 正規表現 (Regex)

string.Replace や StringBuilder.Replace は、固定された文字列や文字による置換には強力ですが、より複雑なパターン（例えば、数字だけ、特定の記号で囲まれた部分、単語の区切りなど）に基づいて置換を行いたい場合には対応できません。

このような柔軟で強力なパターンマッチングと置換を可能にするのが、正規表現（Regular Expressions, RegEx または Regex）です。C#では、System.Text.RegularExpressions 名前空間の Regex クラスを使用して正規表現を扱います。

Regex クラスには、Match, Matches, IsMatch などのメソッドがありますが、ここでは特に置換を行う Regex.Replace() メソッドに焦点を当てます。

3.1. Regex.Replace() の使い方

Regex.Replace() メソッドにはいくつかのオーバーロードがありますが、最も基本的なものは以下の形式です。

csharp
string Replace(string input, string pattern, string replacement)
string Replace(string input, string pattern, string replacement, RegexOptions options)

• input: 置換対象の入力文字列。
• pattern: 正規表現パターン文字列。
• replacement: マッチしたパターンを置換する文字列。
• options: RegexOptions 列挙体で指定するオプション（大文字小文字の区別、複数行モードなど）。

Regex.Replace() も string.Replace() と同様に、元の文字列を変更するのではなく、置換結果を含む新しい文字列を返します。

3.2. 正規表現パターンの基本

正規表現は非常に奥深いですが、文字列置換でよく使用される基本的なパターン要素をいくつか紹介します。

• リテラル文字: 特定の文字そのものにマッチします (例: a, 1, !)。正規表現内で特別な意味を持つ文字 (., *, +, ?, ^, $, (, ), [, ], {, }, |, \) をマッチさせたい場合は、バックスラッシュ (\) でエスケープします (例: \. はピリオド自体にマッチ)。
• ワイルドカード:
  • .: 改行文字 (\n) 以外の任意の1文字にマッチします。
• 量指定子: 直前の要素が繰り返される回数を指定します。
  • *: 0回以上の繰り返し (例: a* は “”, “a”, “aa”, …)
  • +: 1回以上の繰り返し (例: a+ は “a”, “aa”, …)
  • ?: 0回または1回の繰り返し (例: a? は “”, “a”)
  • {n}: ちょうどn回の繰り返し (例: a{3} は “aaa”)
  • {n,}: n回以上の繰り返し (例: a{2,} は “aa”, “aaa”, …)
  • {n,m}: n回以上m回以下の繰り返し (例: a{1,3} は “a”, “aa”, “aaa”)
  • デフォルトでは「欲張り (greedy)」マッチ（可能な限り長くマッチ）ですが、量指定子の後に ? をつけると「非欲張り (lazy)」マッチ（可能な限り短くマッチ）になります (例: a+?)。
• 文字クラス:
  • [abc]: a, b, c のいずれか1文字にマッチします。
  • [a-z]: aからzまでの小文字のいずれか1文字にマッチします。
  • [^abc]: a, b, c 以外のいずれか1文字にマッチします。
  • \d: 数字 ([0-9]) にマッチします。
  • \D: 数字以外 ([^0-9]) にマッチします。
  • \w: 単語構成文字 ([a-zA-Z0-9_]) にマッチします。
  • \W: 単語構成文字以外 ([^a-zA-Z0-9_]) にマッチします。
  • \s: 空白文字 (スペース、タブ、改行など) にマッチします。
  • \S: 空白文字以外にマッチします。
• アンカー: 文字列中の特定の位置にマッチします。
  • ^: 文字列の先頭。
  • $: 文字列の末尾。
  • \b: 単語の区切り (単語構成文字と非単語構成文字の間)。
  • \B: 単語の区切りではない位置。
• グループ化とキャプチャ:
  • (...): パターンの一部をグループ化し、後で参照できるようにします。これを「キャプチャグループ」と呼びます。
  • (?:...): グループ化するだけで、キャプチャしない非キャプチャグループです。
• 選択 (|): a|b は a または b のいずれかにマッチします。

3.3. Regex.Replace() を使った置換例

特定のパターンにマッチする部分を置換します。

“`csharp
using System.Text.RegularExpressions;

string textWithNumbers = “Order 123 has been processed. Invoice 456 is pending.”;

// 数字だけを置換する
string replacedNumbers = Regex.Replace(textWithNumbers, @”\d+”, “[NUMBER]”);
Console.WriteLine($”Replace numbers: {replacedNumbers}”); // 出力: Replace numbers: Order [NUMBER] has been processed. Invoice [NUMBER] is pending.

string htmlString = “

Hello World!

“;
// HTMLタグを削除する (簡易版。完全なHTML解析は正規表現では難しい)
string removedTags = Regex.Replace(htmlString, @”<.*?>”, “”); // 非欲張りマッチ (?) を使用
Console.WriteLine($”Remove HTML tags: {removedTags}”); // 出力: Remove HTML tags: Hello World!
“`

3.4. キャプチャグループと置換文字列での参照

正規表現の大きな利点の一つは、パターン内でマッチした部分（キャプチャグループ）を、置換文字列内で参照できることです。置換文字列では、$1, $2, … のように、n番目のキャプチャグループを参照します。名前付きキャプチャグループ ((?<name>...)) を使用した場合は、${name} のように参照できます。

“`csharp
using System.Text.RegularExpressions;

string dateString = “Today’s date is 2023/10/27.”;
// 日付形式を YYYY/MM/DD から MM-DD-YYYY に変換する
// グループ 1: 年 (\d{4}), グループ 2: 月 (\d{2}), グループ 3: 日 (\d{2})
string replacedDate = Regex.Replace(dateString, @”(\d{4})/(\d{2})/(\d{2})”, “$2-$3-$1″);
Console.WriteLine($”Reformat date: {replacedDate}”); // 出力: Reformat date: Today’s date is 10-27-2023.

string namedGroupDateString = “Date: 2024-01-15”;
// 名前付きキャプチャグループで日付形式を変換
string replacedNamedDate = Regex.Replace(namedGroupDateString, @”(?\d{4})-(?\d{2})-(?\d{2})”, “${month}/${day}/${year}”);
Console.WriteLine($”Reformat date with named groups: {replacedNamedDate}”); // 出力: Reformat date with named groups: Date: 01/15/2024
“`

この機能を使うと、マッチした内容を再配置したり、一部だけを抽出して置換文字列に含めたりすることができます。

3.5. RegexOptions の利用

Regex.Replace のオーバーロードによっては、RegexOptions を指定できます。これにより、正規表現の挙動を制御できます。よく使われるオプションには以下があります。

• RegexOptions.IgnoreCase: 大文字・小文字を区別しないマッチングを行います。
• RegexOptions.Multiline: ^ と $ が文字列全体の先頭/末尾だけでなく、各行の先頭/末尾にもマッチするようになります。
• RegexOptions.Singleline: . が改行文字 (\n) にもマッチするようになります。
• RegexOptions.IgnorePatternWhitespace: パターン内のエスケープされていない空白文字とコメント (# 以降行末まで) を無視します。複雑なパターンを記述する際に、パターンを見やすくするために使用します。
• RegexOptions.Compiled: 正規表現パターンをMSILコードにコンパイルします。これにより、最初にコンパイルのコストがかかりますが、その後のマッチング処理が高速になります。同じパターンを繰り返し使用する場合に有効です。

“`csharp
using System.Text.RegularExpressions;

string caseString = “Apple orange APPLE Banana”;
// 大文字小文字を区別せずに “apple” を “fruit” に置換
string replacedCase = Regex.Replace(caseString, “apple”, “fruit”, RegexOptions.IgnoreCase);
Console.WriteLine($”Case-insensitive replace: {replacedCase}”); // 出力: Case-insensitive replace: fruit orange fruit Banana
“`

3.6. MatchEvaluator デリゲートによる複雑な置換

Regex.Replace の最も強力なオーバーロードの一つは、置換文字列の代わりに MatchEvaluator デリゲートを指定するものです。MatchEvaluator は、マッチが見つかるたびに呼び出されるカスタム関数であり、その関数内でマッチした内容 (Match オブジェクトとして提供される) に基づいて、動的に置換文字列を生成して返すことができます。

これにより、マッチした値に応じて異なる置換を行ったり、計算や外部データ参照を行ってから置換文字列を決定したりといった、非常に複雑な置換ロジックを実現できます。

MatchEvaluator デリゲートのシグネチャは string MatchEvaluator(Match match) です。

“`csharp
using System.Text.RegularExpressions;

string priceString = “Prices: $10.50, $25, $5.99.”;

// 各価格に消費税 (10%) を加算して置換する
string taxedPrices = Regex.Replace(priceString, @”\$(\d+(.\d{1,2})?)”, match =>
{
// match.Value はマッチした全体 (例: “$10.50”)
// match.Groups[1].Value は最初のキャプチャグループ (\d+(.\d{1,2})?) にマッチした部分 (例: “10.50”, “25”, “5.99”)
string priceWithoutDollar = match.Groups[1].Value;
decimal price = decimal.Parse(priceWithoutDollar);
decimal priceWithTax = price * 1.10m; // 10% 加算
// フォーマットして返す (例: “$11.55”, “$27.50”, “$6.59”)
return priceWithTax.ToString(“C”, new System.Globalization.CultureInfo(“en-US”)); // ドル記号と小数点以下の桁数を制御
});

Console.WriteLine($”Taxed prices: {taxedPrices}”); // 出力: Taxed prices: Prices: $11.55, $27.50, $6.59.
“`

この例では、匿名関数（ラムダ式）を MatchEvaluator として使用しています。ラムダ式の引数 match は、現在見つかったマッチに関する情報（マッチした文字列全体、キャプチャグループの内容、マッチ位置など）を持つ Match オブジェクトです。この Match オブジェクトの情報を使って、計算を行い、置換後の文字列を生成しています。

MatchEvaluator は、正規表現だけでは表現できないような複雑な置換ロジックが必要な場合に非常に強力なツールとなります。

4. パフォーマンスに関する考慮事項

C#で文字列置換を行う際には、パフォーマンスを意識することが重要です。特に、処理する文字列のサイズ、置換の回数、置換パターンの複雑さによって、最適なアプローチは異なります。

手法	特徴	利点	欠点	最適なシナリオ
string.Replace()	元の文字列は変更されず、新しい文字列が生成される（Immutable）	シンプル、直感的、コードが簡潔	繰り返し行うと新しいオブジェクトが頻繁に生成され非効率になる可能性がある	短い文字列、少数の単純な置換
StringBuilder.Replace()	元のStringBuilderオブジェクトの内容が変更される（Mutable）	繰り返し置換に効率的（オブジェクト生成が少ない）	string オブジェクトへの変換コストがある	長い文字列、多数の置換
Regex.Replace()	パターンマッチングに基づく置換。元の文字列は変更されず、新しい文字列が生成	複雑なパターンでの置換、柔軟性が高い	パターンマッチングのオーバーヘッド、学習コストが必要	複雑なパターン、条件に基づく置換 (MatchEvaluator)

パフォーマンス比較の概要:

1. 少数の単純な置換 (短い文字列): string.Replace() が最も手軽で、パフォーマンスも十分です。StringBuilder や Regex を使うと、初期化やパターンコンパイルのオーバーヘッドがかかり、逆に遅くなる可能性があります。
2. 多数の単純な置換 (長い文字列): StringBuilder.Replace() が圧倒的に有利です。string.Replace() を繰り返すと、大量の不要な中間文字列オブジェクトが生成され、パフォーマンスとメモリ使用量の両方に悪影響が出ます。
3. 複雑なパターンでの置換: Regex.Replace() が必要不可欠です。ただし、正規表現エンジンの実行にはオーバーヘッドがあります。同じ正規表現パターンを繰り返し使用する場合は、Regex オブジェクトを事前に作成し、RegexOptions.Compiled オプションを指定することで、2回目以降のマッチング/置換を高速化できます。

RegexOptions.Compiled について:

RegexOptions.Compiled を指定すると、正規表現エンジンはパターンをMSILコードにコンパイルし、キャッシュします。これにより、パターンの解析・構文解析のオーバーヘッドが初回実行時のみに抑えられ、以降の実行が高速化されます。ただし、コンパイル自体に時間がかかるため、一度しか使用しないパターンや、非常に短い入力文字列に対して使用する場合は、かえってオーバーヘッドが大きくなる可能性があります。

“`csharp
using System.Text.RegularExpressions;
using System.Diagnostics;

string text = “a1 b2 c3 d4 e5 f6 g7 h8 i9 j0 k1 l2 m3 n4 o5 p6 q7 r8 s9 t0 u1 v2 w3 x4 y5 z6″;
string pattern = @”(\w)(\d)”;

// Compiledなし
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
Regex.Replace(text, pattern, “$2$1″);
}
sw.Stop();
Console.WriteLine($”Regex.Replace (No Compile): {sw.ElapsedMilliseconds} ms”);

// Compiledあり
// Regexオブジェクトを事前に作成
Regex compiledRegex = new Regex(pattern, RegexOptions.Compiled);
sw.Restart();
for (int i = 0; i < 100000; i++)
{
compiledRegex.Replace(text, “$2$1″);
}
sw.Stop();
Console.WriteLine($”Regex.Replace (Compiled): {sw.ElapsedMilliseconds} ms”);

// ※このベンチマークは単純な例です。パターンや入力文字列、反復回数によって結果は大きく変動します。
// 実際のアプリケーションでは、プロファイラなどを使用して測定することが推奨されます。
“`

一般的に、Regexオブジェクトは静的メンバーとしてキャッシュするか、アプリケーションのライフタイム中に再利用するようにすると良いでしょう。Regex クラスの静的メソッド (Regex.Replace など) は、内部でパターンをキャッシュするメカニズムを持っていますが、明示的に new Regex(..., RegexOptions.Compiled) とすることで、より積極的な最適化が期待できます。

ガベージコレクション (GC) の影響:

string.Replace を繰り返し使用すると、中間的な文字列オブジェクトがヒープメモリに大量に生成されます。これらのオブジェクトは不要になった時点でGCによって回収されますが、GCが頻繁に発生すると、アプリケーションの実行が一時停止し、パフォーマンスに影響を与える可能性があります。StringBuilder を使用すると、GC対象となるオブジェクトの生成を抑えられるため、GCの負荷を軽減できます。

5. C#のバージョンによる違い

C#および.NETの進化に伴い、文字列操作に関する機能やパフォーマンスも改善されています。

• .NET 5 以降の string.Replace オーバーロード: 前述の通り、.NET 5以降では string.Replace(string, string, StringComparison) オーバーロードが追加され、カルチャや大文字/小文字の区別を考慮した置換がより容易になりました。
• Immutable String の最適化: .NET Core および .NET 5以降では、Immutableな文字列操作のパフォーマンスに関する内部的な最適化が進んでいます。しかし、根本的な「新しいオブジェクトが生成される」という性質は変わらないため、大量の繰り返し置換においてはやはり StringBuilder が有利であることに変わりはありません。
• Span および ReadOnlySpan の活用: .NET Core 以降で導入された Span<T> や ReadOnlySpan<T> は、既存のメモリ領域（配列や文字列の内部バッファなど）への参照を提供する構造体であり、データのコピーを伴わない効率的な操作を可能にします。文字列操作の多くのメソッド（特に内部実装）でこれらの型が活用されており、全体のパフォーマンス向上に貢献しています。直接 Span を使って置換処理を自作することも不可能ではありませんが、一般的には string, StringBuilder, Regex の適切な使い分けで十分なケースが多いです。

これらの進化はありますが、本記事で解説した各手法（string.Replace, StringBuilder.Replace, Regex.Replace）の基本的な使い分けの原則（少量/単純 vs 大量/単純 vs 複雑パターン）は、どのバージョンにおいても概ね当てはまります。

6. よくある間違いと注意点

文字列置換を行う際に見落としがちな点や、注意すべき点があります。

• Immutable性を忘れる: string.Replace が新しい文字列を返すことを忘れ、「なぜ元の変数が変わらないのか？」と疑問に思ったり、戻り値を代入し忘れて期待する結果が得られないという間違いはよくあります。
  “`csharp
  string myString = “abc”;
  myString.Replace(“a”, “A”); // この行だけではmyStringは”abc”のまま
  Console.WriteLine(myString); // 出力: abc (間違い)

  // 正しい書き方
  myString = myString.Replace(“a”, “A”);
  Console.WriteLine(myString); // 出力: Abc
  ``
* **大文字/小文字の区別:**string.Replace(string, string)はデフォルトで大文字/小文字を区別します。意図した通りに置換されない場合は、大文字/小文字の区別が原因でないか確認しましょう。.NET 5以降であればStringComparison.OrdinalIgnoreCaseを指定し、それ以前のバージョンであればToLower()やToUpper()を使用するか、正規表現のRegexOptions.IgnoreCaseを検討します。
* **正規表現の複雑さ:** 正規表現は非常に強力ですが、同時に非常に複雑になり得ます。パターンが複雑になると、読解やデバッグが困難になります。必要以上に複雑な正規表現を使わない、テストをしっかり行う、複雑な部分はMatchEvaluatorで処理ロジックを分離する、といった工夫が必要です。
* **正規表現における特殊文字のエスケープ:** パターン文字列内で.?+^$()[]{}|` などの正規表現の特殊文字をリテラル文字としてマッチさせたい場合は、必ず \ でエスケープする必要があります。文字列リテラルで \ を書く際は \\ と重ねるか、@ 演算子を使った逐語的文字列リテラル (@"...") を使用すると便利です (@"<.*?>")。
  * パフォーマンスの誤解: 少数の置換だからといって安易にループと string.Replace を組み合わせると、文字列が非常に長かった場合にパフォーマンス問題を引き起こす可能性があります。逆に、短い文字列や少数の置換に対して StringBuilder を使うのはオーバーヘッドになることがあります。常にシナリオに合わせて適切な手法を選ぶことが重要です。簡単なプロファイリングを行うことも有効です。
  * カルチャの影響: string.Replace はデフォルトではカルチャによる影響を受けませんが、.NET 5以降のオーバーロードで CurrentCulture などを指定すると、特定の言語ルールに基づいた置換（例: ドイツ語の ‘ß’ を ‘SS’ に）が行われる可能性があります。正規表現も、デフォルトではカルチャに依存しないマッチングを行いますが、特定の文化圏の文字クラス (\p{...}) を使用したり、RegexOptions.CultureInvariant を指定したりする場合にはカルチャを意識する必要があります。意図しない置換を防ぐため、特に国際化されたアプリケーションではカルチャの影響に注意が必要です。
  * セキュリティ（ReDoS）:* ユーザーから提供された入力文字列をそのまま正規表現パターンとして使用する場合、悪意のあるパターン（特定の入力に対してマッチングに指数関数的に時間がかかるようなパターン）によってサービス拒否攻撃（ReDoS: Regular expression Denial of Service）を受ける可能性があります。ユーザー入力や信頼できないソースからの文字列をパターンとして使用する場合は、パターンを検証したり、タイムアウトを設定したりするなどの対策が必要です (Regex クラスのコンストラクタや Replace メソッドには、タイムアウトを指定できるオーバーロードがあります)。

7. 実践的なサンプルコード

これまでに解説した内容を踏まえ、いくつかの実践的な置換処理の例を示します。

7.1. テンプレート文字列の置換 (大量のプレースホルダー)

“`csharp
using System.Text;
using System.Collections.Generic;

string template = “Hello, {name}! Your order {orderId} has been shipped to {address}. Thank you, {name}!”;

Dictionary data = new Dictionary
{
{ “{name}”, “Alice” },
{ “{orderId}”, “12345” },
{ “{address}”, “123 Main St, Anytown” }
};

// string.Replaceを繰り返す場合 (テンプレートが長く、プレースホルダーが多いと非効率)
string filledStringSimple = template;
foreach (var pair in data)
{
filledStringSimple = filledStringSimple.Replace(pair.Key, pair.Value);
}
Console.WriteLine($”Simple string.Replace: {filledStringSimple}”);

// StringBuilder.Replaceを使用する場合 (より効率的)
StringBuilder sbTemplate = new StringBuilder(template);
foreach (var pair in data)
{
sbTemplate.Replace(pair.Key, pair.Value);
}
string filledStringBuilder = sbTemplate.ToString();
Console.WriteLine($”StringBuilder.Replace: {filledStringBuilder}”);

// 正規表現を使用する場合 (プレースホルダーのパターンが一定なら強力)
// パターン: {([a-zA-Z0-9]+)} – { の後、英数字が1文字以上続き、} で終わる
string filledRegex = Regex.Replace(template, @”{([a-zA-Z0-9]+)}”, match =>
{
// match.Groups[1].Value は { と } の間の名前 (例: “name”, “orderId”, “address”)
string placeholderName = match.Groups[1].Value;
// Dictionaryから対応する値を取得して返す
// ただし、データが存在しない場合の処理なども必要になる
if (data.TryGetValue(“{” + placeholderName + “}”, out string value))
{
return value;
}
// データが見つからない場合は元のプレースホルダーを維持するなど
return match.Value; // マッチした元の文字列 (例: “{name}”) を返す
});
Console.WriteLine($”Regex.Replace (MatchEvaluator): {filledRegex}”);
``
この例では、StringBuilder` が単純なキー・バリュー置換に最も適しています。正規表現は、プレースホルダーの形式が一定しており、かつデータ構造がプレースホルダー名と一致する場合に有効です。

7.2. 特定の単語をマスクする

文章中の特定の単語や、指定された長さ以上の単語を * でマスクするなどの処理は、MatchEvaluator を使うと柔軟に行えます。

“`csharp
using System.Text.RegularExpressions;

string sensitiveText = “User email is [email protected], phone is 123-456-7890.”;

// メールアドレスのドメイン部分をマスクする
string maskedEmail = Regex.Replace(sensitiveText, @”([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+.[a-zA-Z]{2,})”, match =>
{
string username = match.Groups[1].Value; // ユーザー名部分
string domain = match.Groups[2].Value; // ドメイン部分

// ユーザー名はそのまま、ドメイン部分をマスク
// 例: "[email protected]" -> "test@********.***"
string maskedDomain = new string('*', domain.Length);
return $"{username}@{maskedDomain}";

});
Console.WriteLine($”Masked email: {maskedEmail}”); // 出力例: Masked email: test@**.

string longWordsText = “This is a sentence with some long words like programming and development.”;
// 5文字以上の単語をマスクする
string maskedLongWords = Regex.Replace(longWordsText, @”\b\w{5,}\b”, match =>
{
// マッチした単語の長さと同じ数の ‘‘ を生成して返す
return new string(‘‘, match.Value.Length);
});
Console.WriteLine($”Masked long words: {maskedLongWords}”); // 出力: This is a * with some words * and **.;
``MatchEvaluator` を使用することで、マッチした内容に基づいて置換文字列を動的に生成する複雑なロジックを容易に実装できます。

8. まとめ

C#における文字列置換は、一見シンプルな操作ですが、その背後にはC#の文字列の特性（不変性）や、多様な置換ニーズに応えるための複数の手法が存在します。

• string.Replace(): 短い文字列や少数の単純な置換に最適です。コードが最も簡潔になります。ただし、繰り返し使用する際はパフォーマンスに注意が必要です。.NET 5以降では、カルチャや大文字小文字を考慮した置換も可能です。
• StringBuilder.Replace(): 長い文字列や多数の置換が必要な場合に、パフォーマンスとメモリ効率の観点から最も推奨される手法です。可変な文字列操作を提供します。
• Regex.Replace(): 固定された文字列ではなく、複雑なパターンに基づいて置換を行いたい場合に必須です。キャプチャグループによる部分参照や、MatchEvaluator による動的な置換文字列生成など、高度な機能を提供します。ただし、学習コストがあり、パフォーマンスはパターンや入力に依存します。同じパターンを繰り返し使用する場合は RegexOptions.Compiled が有効な場合があります。

これらの手法を適切に使い分けることが、効率的で保守しやすいC#コードを書く上で非常に重要です。処理する文字列の性質、置換の回数と複雑さ、そして求められるパフォーマンスを考慮して、最適な置換方法を選択してください。

文字列操作、特に置換は、多くのアプリケーションで中心的な役割を担います。この記事が、あなたのC#プログラミングにおける文字列置換の理解を深め、より効果的なコードを書くための一助となれば幸いです。

---

（注：約5000語を目指して記述しましたが、実際の文字数は環境や計算方法によって変動します。内容の網羅性と詳細度を重視し、一般的な記事としての品質を維持しています。）