文字列

【C#】Regex.Replaceで学ぶ正規表現置換の基本と応用テクニック

2025-04-30更新日: 2025-04-30

C#のRegex.Replaceは検索と置換をワンステップで行い、一括修正や動的変換を最小限のコードで実装できます。

$0などの置換トークンやMatchEvaluatorを組み合わせることで、数字の削除から条件付きの文字列加工まで柔軟に対応でき、バグ削減と保守効率の向上が期待できます。

目次から探す

Regex.Replaceの基本シンタックス
置換トークンの使い方
一致部分を動的に加工するMatchEvaluator
正規表現のよくあるパターン集
パフォーマンス最適化のポイント
エラーと例外への対処
ユースケース別サンプル
テストとデバッグ方法
メンテナンスしやすいコード設計
セキュリティの考慮事項
.NETバージョンごとの違い
まとめ

Regex.Replaceの基本シンタックス

C#で正規表現を使った文字列置換を行う際に、最も基本となるのがRegex.Replaceメソッドです。

このメソッドは、指定した正規表現パターンにマッチした部分を別の文字列に置き換える機能を提供します。

ここでは、Regex.Replaceのメソッドシグネチャや主要なオーバーロード、そして最小限のコードで置換を実行する方法、さらにオプションフラグの付与方法について詳しく解説します。

メソッドシグネチャと主要オーバーロード

Regex.Replaceメソッドは、System.Text.RegularExpressions名前空間に属しており、静的メソッドとして利用できます。

主に使われるオーバーロードは以下の通りです。

基本的な置換

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

input：置換対象の文字列
pattern：正規表現パターン
replacement：置換後の文字列

このオーバーロードは、input文字列の中でpatternにマッチした部分をすべてreplacementに置き換えます。

正規表現オプションを指定する置換

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

options：正規表現の動作を制御するフラグ(例：大文字小文字の無視、マルチラインモードなど)

MatchEvaluatorを使った動的置換

public static string Replace(string input, string pattern, MatchEvaluator evaluator);

evaluator：マッチした部分を動的に置換するためのデリゲート

MatchEvaluatorとオプションを組み合わせた置換

public static string Replace(string input, string pattern, MatchEvaluator evaluator, RegexOptions options);

これらのオーバーロードを使い分けることで、単純な文字列置換から複雑な動的置換まで柔軟に対応できます。

最小限のコードで置換を実行する手順

まずは、最もシンプルな例でRegex.Replaceを使った置換を行う方法を紹介します。

例えば、文字列中の数字をすべて削除するケースです。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Samurai123Engineer";
        string pattern = @"\d+"; // 数字にマッチする正規表現
        string replacement = ""; // 空文字で置換(削除)
        string result = Regex.Replace(input, pattern, replacement);
        Console.WriteLine(result); // 出力: SamuraiEngineer
    }
}

SamuraiEngineer

このコードでは、\d+という正規表現パターンで連続した数字にマッチし、それらを空文字に置き換えています。

Regex.Replaceはマッチしたすべての部分を対象に置換を行うため、数字がすべて削除されます。

このように、Regex.Replaceは非常にシンプルなコードで強力な置換処理を実現できます。

オプションフラグの付与方法

Regex.Replaceでは、正規表現の動作を細かく制御するためにRegexOptions列挙体を使ってオプションを指定できます。

主なオプションには以下のようなものがあります。

オプション名	説明
`RegexOptions.IgnoreCase`	大文字小文字を区別せずにマッチさせる
`RegexOptions.Multiline`	`^`や`$`を行頭・行末にマッチさせる
`RegexOptions.Singleline`	`.`が改行文字にもマッチするようにする
`RegexOptions.Compiled`	正規表現をコンパイルして高速化する
`RegexOptions.CultureInvariant`	文化依存しないマッチングを行う

これらのオプションは、Regex.Replaceのオーバーロードで指定できます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Hello\nHELLO\nhello";
        string pattern = @"hello";
        string replacement = "Hi";
        // 大文字小文字を無視して置換
        string result = Regex.Replace(input, pattern, replacement, RegexOptions.IgnoreCase);
        Console.WriteLine(result);
    }
}

Hi
Hi
Hi

この例では、RegexOptions.IgnoreCaseを指定することで、helloの大文字・小文字を区別せずにすべてHiに置換しています。

また、複数のオプションを組み合わせる場合はビット演算子|を使います。

RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Multiline;

このように、RegexOptionsを活用することで、より細かい制御が可能になります。

特に大文字小文字の無視や複数行テキストの処理では必須のオプションです。

以上がRegex.Replaceの基本的なシンタックスと使い方です。

次のステップでは、置換パターン内での正規表現要素の活用や、動的に置換内容を決定するMatchEvaluatorの使い方について解説します。

置換トークンの使い方

Regex.Replaceの置換文字列内では、正規表現のマッチ内容を参照するための特別なトークンを使えます。

これにより、マッチした部分をそのまま再利用したり、キャプチャグループの内容を組み込んだりすることが可能です。

ここでは、代表的なトークンの使い方を具体例とともに説明します。

$0 と$ & の違い

と $& の違い

置換文字列内でマッチした部分全体を参照するトークンとして、$0と$&があります。

どちらもマッチした文字列全体を表しますが、C#のRegex.Replaceでは$&が正式にサポートされているトークンです。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "吾輩は猫です。吾輩は子犬です。";
        string pattern = @".+?。"; // 文にマッチする正規表現
        // $&を使ってマッチした文を引用符で囲む
        string result = Regex.Replace(input, pattern, "「$&」");
        Console.WriteLine(result);
    }
}

「吾輩は猫です。」「吾輩は子犬です。」

この例では、$&がマッチした文全体を指し、置換文字列の中でそのまま使われています。

$0は.NETの正規表現置換ではサポートされていないため、代わりに$&を使うようにしてください。

キャプチャグループ以降の利用例

正規表現のパターン内で丸括弧()を使うと、キャプチャグループが作成されます。

置換文字列内では、$1、$2、…のように数字でグループ番号を指定して、そのグループにマッチした部分を参照できます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "2024-06-15";
        string pattern = @"(\d{4})-(\d{2})-(\d{2})"; // 年、月、日をキャプチャ
        // 日付の形式を「YYYY年MM月DD日」に変換
        string replacement = "$1年$2月$3日";
        string result = Regex.Replace(input, pattern, replacement);
        Console.WriteLine(result);
    }
}

2024年06月15日

この例では、(\d{4})が年、(\d{2})が月、(\d{2})が日をそれぞれキャプチャし、置換文字列で$1、$2、$3として参照しています。

これにより、元の文字列の一部を再利用しつつ、フォーマットを変換できます。

名前付きキャプチャと ${name} の活用

キャプチャグループには名前を付けることもでき、その場合は${name}という形式で置換文字列内から参照します。

名前付きキャプチャは、複雑な正規表現や複数のグループがある場合に可読性が高まります。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "2024-06-15";
        string pattern = @"(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})";
        // 名前付きキャプチャを使って日付形式を変換
        string replacement = "${year}年${month}月${day}日";
        string result = Regex.Replace(input, pattern, replacement);
        Console.WriteLine(result);
    }
}

2024年06月15日

名前付きキャプチャは、グループ番号を覚えなくてもよく、置換文字列の意味が直感的にわかるため、メンテナンス性が向上します。

エスケープが必要なケース

置換文字列内で$や\を文字として使いたい場合は、エスケープが必要です。

特に$は置換トークンの開始文字なので、単なる文字として使うには$$と書きます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "価格は1000円です。";
        string pattern = @"(\d+)";
        // 数字の前に「$」を付けて通貨表記にします。ただし$はエスケープが必要
        string replacement = "$$$1"; // $$で$を表し、$1でキャプチャグループを参照
        string result = Regex.Replace(input, pattern, replacement);
        Console.WriteLine(result);
    }
}

価格は$1000円です。

この例では、$$が文字としての$を表し、$1がキャプチャグループの数字を参照しています。

\を文字として使いたい場合は\\とエスケープしてください。

置換文字列内でのエスケープを正しく理解しないと、意図しない置換結果になることがあるため注意が必要です。

一致部分を動的に加工するMatchEvaluator

Regex.Replaceメソッドでは、置換文字列を静的に指定するだけでなく、MatchEvaluatorデリゲートを使ってマッチした部分を動的に加工しながら置換できます。

これにより、マッチ内容に応じて複雑な変換や条件分岐を行うことが可能です。

MatchEvaluatorの基本構造

MatchEvaluatorは、System.Text.RegularExpressions名前空間にあるデリゲートで、Matchオブジェクトを受け取り、置換後の文字列を返す関数の形をとります。

基本的な構造は以下の通りです。

string Evaluator(Match match)
{
    // match.Valueやmatch.Groupsを使って置換文字列を生成
    return "置換後の文字列";
}

この関数をRegex.Replaceの第3引数に渡すことで、マッチごとに呼び出され、返した文字列で置換されます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static string ChangeExtension(Match match)
    {
        if (match.Value.EndsWith(".bak"))
            return match.Value;
        else
            return match.Value + ".bak";
    }
    static void Main()
    {
        string[] files = { "sample.txt", "sample.txt.bak", "sample.cs" };
        string pattern = @"\..*";
        foreach (string file in files)
        {
            string result = Regex.Replace(file, pattern, new MatchEvaluator(ChangeExtension));
            Console.WriteLine($"{file} => {result}");
        }
    }
}

sample.txt => sample.txt.bak
sample.txt.bak => sample.txt.bak
sample.cs => sample.cs.bak

この例では、拡張子がすでに.bakで終わっている場合はそのまま返し、そうでなければ.bakを付加しています。

デリゲートとラムダ式の書き分け

MatchEvaluatorはデリゲートなので、メソッド名を指定する方法のほかに、匿名メソッドやラムダ式で記述することもできます。

ラムダ式を使うとコードが簡潔になり、特に短い処理に向いています。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123def456";
        string pattern = @"\d+";
        // 数字部分を2倍にするラムダ式
        string result = Regex.Replace(input, pattern, match =>
        {
            int num = int.Parse(match.Value);
            return (num * 2).ToString();
        });
        Console.WriteLine(result);
    }
}

abc246def912

この例では、数字にマッチした部分を整数に変換し、2倍にしてから文字列に戻して置換しています。

ラムダ式はスコープ内の変数も参照できるため、柔軟に使えます。

外部パラメーターを渡すテクニック

MatchEvaluator内で外部の変数や設定値を使いたい場合、クロージャを利用して変数を参照する方法が一般的です。

これにより、関数の引数として渡せない値も利用可能になります。

クロージャを利用した変数参照

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        int multiplier = 3;
        string input = "num1=10; num2=20; num3=30;";
        string pattern = @"\d+";
        string result = Regex.Replace(input, pattern, match =>
        {
            int val = int.Parse(match.Value);
            return (val * multiplier).ToString();
        });
        Console.WriteLine(result);
    }
}

num1=30; num2=60; num3=90;

この例では、multiplier変数をラムダ式内で参照し、数字を3倍にしています。

クロージャにより、multiplierの値をMatchEvaluatorに渡すことができています。

設定ファイルと連携するケース

設定ファイルや外部データを読み込んで置換処理に反映させる場合も、同様にクロージャを使うことが多いです。

例えば、置換ルールを辞書で管理し、マッチした文字列を対応する値に置き換える例です。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        var replacements = new Dictionary<string, string>
        {
            { "apple", "りんご" },
            { "banana", "バナナ" },
            { "orange", "オレンジ" }
        };
        string input = "I like apple and banana.";
        string pattern = @"apple|banana|orange";
        string result = Regex.Replace(input, pattern, match =>
        {
            string key = match.Value;
            return replacements.ContainsKey(key) ? replacements[key] : key;
        });
        Console.WriteLine(result);
    }
}

I like りんご and バナナ.

このように、外部の設定データを活用して動的に置換内容を決定できます。

大規模ファイルを処理する際の注意点

大量のテキストや大規模ファイルに対してRegex.ReplaceをMatchEvaluatorで処理する場合、パフォーマンスやメモリ使用量に注意が必要です。

正規表現のコンパイル

RegexOptions.Compiledを使うことで、正規表現の実行速度を向上させられます。

ただし、初回のコンパイルに時間がかかるため、繰り返し使う場合に効果的です。

インスタンスの再利用

Regex.Replaceの静的メソッドではなく、Regexクラスのインスタンスを作成して使うと、同じパターンを何度も使う際に効率的です。

var regex = new Regex(pattern, RegexOptions.Compiled);
string result = regex.Replace(input, evaluator);

メモリ消費の抑制

大きな文字列を一度に処理するとメモリを大量に消費するため、可能であれば分割して処理するか、ストリーム処理を検討してください。

例外処理

マッチ処理中に例外が発生すると処理が中断されるため、MatchEvaluator内で例外が起きそうな処理は適切にハンドリングしましょう。

タイムアウト設定

複雑な正規表現で処理が長時間かかる場合、Regexインスタンスのタイムアウトを設定して無限ループや過剰なバックトラックを防ぐことができます。

var regex = new Regex(pattern, RegexOptions.Compiled, TimeSpan.FromSeconds(2));

これらのポイントを踏まえて、大規模データの置換処理を設計すると安定した動作が期待できます。

正規表現のよくあるパターン集

日常的に使われる正規表現のパターンを活用した文字列置換の例を紹介します。

数字や通貨のフォーマット変換、日付の形式統一、電子メールアドレスのバリデーションやマスク、URLのリダイレクト書き換え、複数行テキストの整形など、実務で役立つパターンを取り上げます。

数字・通貨のフォーマット変換

数字や通貨表記のフォーマットを正規表現で変換するケースは多いです。

例えば、3桁ごとにカンマを挿入して見やすくしたり、通貨記号を付加したりします。

using System;
using System.Text.RegularExpressions;
using System.Globalization;
class Program
{
    static void Main()
    {
        string input = "1234567";
        // 数字の3桁ごとにカンマを挿入する正規表現
        string pattern = @"\B(?=(\d{3})+(?!\d))";
        // 置換文字列はカンマ
        string result = Regex.Replace(input, pattern, ",");
        Console.WriteLine(result); // 出力: 1,234,567
        // 通貨記号を付ける例
        decimal amount = 1234567.89m;
        string formatted = amount.ToString("C", CultureInfo.CreateSpecificCulture("en-US"));
        Console.WriteLine(formatted); // 出力: $1,234,567.89
    }
}

1,234,567
$1,234,567.89

この例では、\B(?=(\d{3})+(?!\d))というパターンで数字の3桁区切りの位置を検出し、カンマを挿入しています。

通貨記号の付加はdecimal.ToStringのフォーマット機能を使うのが一般的ですが、正規表現で数字部分を加工することも可能です。

日付の形式統一

日付の表記は様々な形式があり、正規表現で統一的なフォーマットに変換することがよくあります。

例えば、YYYY/MM/DD形式をYYYY年MM月DD日に変換する例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "2024/06/15";
        string pattern = @"(\d{4})/(\d{2})/(\d{2})";
        string replacement = "$1年$2月$3日";
        string result = Regex.Replace(input, pattern, replacement);
        Console.WriteLine(result); // 出力: 2024年06月15日
    }
}

2024年06月15日

また、日付の区切り文字が-や.の場合も同様に対応できます。

string input2 = "2024-06-15";
string pattern2 = @"(\d{4})[-\.](\d{2})[-\.](\d{2})";
string result2 = Regex.Replace(input2, pattern2, replacement);
Console.WriteLine(result2); // 出力: 2024年06月15日

電子メールアドレスのバリデーションとマスク

メールアドレスの形式チェックや、個人情報保護のために一部をマスクする処理も正規表現で行います。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "user@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        bool isValid = Regex.IsMatch(input, pattern);
        Console.WriteLine($"メールアドレスの形式チェック: {isValid}"); // 出力: True
        // メールアドレスのユーザー名部分をマスクする
        string maskPattern = @"(^[\w\.-]{1})[\w\.-]+(@[\w\.-]+\.\w+$)";
        string masked = Regex.Replace(input, maskPattern, "$1***$2");
        Console.WriteLine($"マスク後: {masked}"); // 出力: u***@example.com
    }
}

メールアドレスの形式チェック: True
マスク後: u***@example.com

この例では、メールアドレスの基本的な形式をチェックし、ユーザー名の先頭1文字以外を***に置換しています。

より厳密なバリデーションは専用ライブラリを使うことが望ましいですが、簡易的なチェックには十分です。

URLのリダイレクト書き換え

WebアプリケーションなどでURLの一部を書き換えるケースもあります。

例えば、HTTPからHTTPSに変換したり、特定のパスを別のパスにリダイレクトしたりします。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "http://example.com/page1";
        string pattern = @"^http://";
        // httpをhttpsに置換
        string result = Regex.Replace(input, pattern, "https://");
        Console.WriteLine(result); // 出力: https://example.com/page1
        // 特定のパスを別のパスに書き換え
        string url = "https://example.com/oldpath/resource";
        string pathPattern = @"/oldpath/";
        string replacedUrl = Regex.Replace(url, pathPattern, "/newpath/");
        Console.WriteLine(replacedUrl); // 出力: https://example.com/newpath/resource
    }
}

https://example.com/page1
https://example.com/newpath/resource

このように、URLのスキームやパス部分を正規表現で検出して置換できます。

複数行テキストの整形

複数行のテキストを扱う場合、改行コードの統一や余分な空白の除去などの整形処理が必要になることがあります。

改行コードの統一

Windowsの改行コードは\r\n、Unix系は\n、Mac(古い)は\rと異なるため、統一することが多いです。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Line1\r\nLine2\nLine3\rLine4";
        // 改行コードをすべて\nに統一
        string pattern = @"\r\n|\r";
        string result = Regex.Replace(input, pattern, "\n");
        Console.WriteLine(result);
    }
}

Line1
Line2
Line3
Line4

この例では、\r\nと\rをまとめて\nに置換しています。

余分な空白の除去

行頭や行末の空白、連続する空白を1つにまとめるなどの処理もよく行われます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "  This   is   a   test.  \n  Another    line.  ";
        // 行頭・行末の空白を削除
        string trimmed = Regex.Replace(input, @"^\s+|\s+$", "", RegexOptions.Multiline);
        // 連続する空白を1つにまとめる
        string normalized = Regex.Replace(trimmed, @"\s{2,}", " ");
        Console.WriteLine(normalized);
    }
}

This is a test.
Another line.

^\s+|\s+$は行頭または行末の空白を表し、RegexOptions.Multilineで各行に適用されます。

続いて、\s{2,}で2つ以上の空白を1つにまとめています。

これらのパターンは実務で頻繁に使われるため、正規表現の基本と組み合わせて覚えておくと便利です。

パフォーマンス最適化のポイント

正規表現は強力な文字列処理手段ですが、複雑なパターンや大量のデータに対して使うとパフォーマンスに影響が出ることがあります。

C#のRegexクラスにはパフォーマンスを向上させるための機能や工夫が用意されているため、適切に活用することが重要です。

RegexOptions.Compiled の効果

RegexOptions.Compiledは、正規表現パターンをILコードにコンパイルして高速化を図るオプションです。

通常、Regexはパターンを解析して内部表現を作成し、マッチングを行いますが、Compiledを指定すると、これを事前にネイティブコードに変換します。

using System;
using System.Text.RegularExpressions;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string input = "abc123def456ghi789";
        string pattern = @"\d+";
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < 10000; i++)
        {
            Regex.Replace(input, pattern, "#");
        }
        sw.Stop();
        Console.WriteLine($"通常のRegex.Replace: {sw.ElapsedMilliseconds} ms");
        var regexCompiled = new Regex(pattern, RegexOptions.Compiled);
        sw.Restart();
        for (int i = 0; i < 10000; i++)
        {
            regexCompiled.Replace(input, "#");
        }
        sw.Stop();
        Console.WriteLine($"Compiledオプション使用時: {sw.ElapsedMilliseconds} ms");
    }
}

通常のRegex.Replace: 9 ms
Compiledオプション使用時: 6 ms

(※実行環境により数値は異なります)

RegexOptions.Compiledは初回のコンパイルに時間がかかるため、単発の処理では逆に遅くなることもありますが、繰り返し同じパターンを使う場合は大幅に高速化します。

大量の置換処理や頻繁に呼び出す場面では積極的に使うべきオプションです。

RegexCacheとインスタンス再利用

Regex.Replaceの静的メソッドは内部でパターンをキャッシュしていますが、キャッシュサイズには限りがあります。

大量の異なるパターンを使う場合や、パターンを頻繁に生成する場合はキャッシュミスが発生しやすくなります。

そのため、パターンが固定されている場合はRegexインスタンスを作成して再利用するのが望ましいです。

var regex = new Regex(pattern, RegexOptions.Compiled);
for (int i = 0; i < 10000; i++)
{
    string result = regex.Replace(input, "#");
}

この方法は、パターン解析やコンパイルを一度だけ行い、以降は高速にマッチング・置換が可能です。

特にWebアプリケーションやサービスのように長時間動作する環境では、インスタンスの再利用がパフォーマンスとメモリ効率の両面で効果的です。

Span<char> と RegexGenerator 対応

.NET 6以降では、Span<char>を使った正規表現APIや、ソースジェネレーターによるRegexGenerator属性が導入され、さらにパフォーマンスが向上しています。

Span<char>対応

Span<char>はメモリ効率が良く、文字列の部分スライスをコピーせずに扱えます。

これにより、正規表現のマッチングや置換処理でのメモリアロケーションを削減できます。

RegexGenerator属性

ソースジェネレーターを使い、コンパイル時に正規表現のコードを生成する仕組みです。

これにより、実行時のパターン解析やコンパイルが不要になり、非常に高速な処理が可能です。

using System.Text.RegularExpressions;
[GeneratedRegex(@"\d+")]
partial class MyRegex
{
}
class Program
{
    static void Main()
    {
        var regex = new MyRegex();
        string input = "abc123def456";
        string result = regex.Replace(input, "#");
        Console.WriteLine(result); // 出力: abc#def#
    }
}

この機能は.NET 7以降で利用可能で、パフォーマンス重視のアプリケーションで注目されています。

ベンチマークの取り方

正規表現のパフォーマンスを評価するには、単純な時間計測だけでなく、正確なベンチマークを行うことが重要です。

以下のポイントを押さえましょう。

Stopwatchクラスの利用

高精度な時間計測が可能です。

複数回のループで平均を取ると安定した結果が得られます。

ウォームアップ

初回のJITコンパイルやRegexOptions.Compiledのコンパイル時間を除外するため、最初に数回処理を実行してウォームアップします。

GCの影響を考慮

ガベージコレクションが走ると計測に影響が出るため、GC.Collect()やGC.WaitForPendingFinalizers()で事前にメモリを整理することもあります。

BenchmarkDotNetの活用

より正確で詳細なベンチマークを行いたい場合は、BenchmarkDotNetというライブラリを使うと便利です。

自動でウォームアップやGC制御、統計処理を行ってくれます。

// BenchmarkDotNetの簡単な例
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Text.RegularExpressions;
public class RegexBenchmark
{
    private string input = "abc123def456ghi789";
    private Regex regexCompiled = new Regex(@"\d+", RegexOptions.Compiled);
    private string pattern = @"\d+";
    [Benchmark]
    public string StaticReplace() => Regex.Replace(input, pattern, "#");
    [Benchmark]
    public string CompiledReplace() => regexCompiled.Replace(input, "#");
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<RegexBenchmark>();
    }
}

このように、ベンチマークを正しく行うことで、どの方法が最適か判断しやすくなります。

パフォーマンス改善の効果を数値で確認しながら開発を進めることが重要です。

エラーと例外への対処

正規表現を使った置換処理では、パターンの誤りや複雑な構造によって例外やパフォーマンス問題が発生することがあります。

ここでは、よくあるエラーの種類とその対処法、さらにデバッグやログ出力のポイントを解説します。

非対応パターンによる ArgumentException

Regexのパターンに誤りがある場合、ArgumentExceptionがスローされます。

例えば、括弧の閉じ忘れや不正なエスケープシーケンスが原因です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        try
        {
            string pattern = @"(\d+"; // 括弧の閉じ忘れ
            string input = "12345";
            Regex.Replace(input, pattern, "#");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"正規表現のパターンエラー: {ex.Message}");
        }
    }
}

正規表現のパターンエラー: Invalid pattern '(\d+' at offset 4. Not enough )'s.

この例では、開き括弧(に対応する閉じ括弧)がないため、ArgumentExceptionが発生しています。

パターンを作成する際は、括弧の対応やエスケープ文字の正確さを必ず確認してください。

Visual Studioの正規表現エディタやオンラインツール(Regex101など)で事前に検証することも有効です。

無限ループを招くバックトラック

複雑な正規表現や曖昧なパターンは、マッチング時に大量のバックトラックを発生させ、処理が極端に遅くなることがあります。

これを「バックトラック爆発」と呼び、実質的に無限ループのような状態になることもあります。

例えば、以下のようなパターンは注意が必要です。

string pattern = @"(a+)+b";
string input = "aaaaaaaaaaaaaaaaaaaaa";

このパターンはaの繰り返しを複数回ネストしているため、bが続かない入力に対して膨大なバックトラックが発生します。

対策としては、

パターンの見直し

ネストした繰り返しを避けます。

例えば、(a+)+をa+に単純化します。

非貪欲マッチの活用

+?や*?を使い、必要以上にマッチを広げない。

具体的な文字列を明示する

曖昧なパターンを減らし、マッチ範囲を限定します。

タイムアウト設定を利用する(後述)

タイムアウト設定で防ぐDoS

正規表現のバックトラック爆発は、悪意のある入力や誤ったパターンでサービス拒否(DoS)攻撃の原因になることがあります。

これを防ぐために、Regexクラスではタイムアウトを設定できます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"(a+)+b";
        string input = "aaaaaaaaaaaaaaaaaaaaa";
        try
        {
            var regex = new Regex(pattern, RegexOptions.None, TimeSpan.FromMilliseconds(1));
            string result = regex.Replace(input, "#");
            Console.WriteLine(result);
        }
        catch (RegexMatchTimeoutException ex)
        {
            Console.WriteLine("正規表現の処理がタイムアウトしました。");
        }
    }
}

正規表現の処理がタイムアウトしました。

RegexのコンストラクタにTimeSpanを指定すると、その時間を超えたマッチング処理はRegexMatchTimeoutExceptionをスローして中断されます。

これにより、無限ループや過剰なバックトラックによるシステム停止を防止できます。

デバッグ表示とログ出力のコツ

正規表現の問題を特定するには、マッチ結果や置換後の文字列を適切にログに出力することが重要です。

マッチした部分の表示

MatchオブジェクトのValueやGroupsをログに出すと、どの部分がマッチしているか把握しやすくなります。

例外情報の詳細ログ

例外のメッセージやスタックトレースを記録し、パターンのどこでエラーが起きているか確認します。

正規表現のパターン自体をログに残す

動的に生成するパターンの場合、実際に使われたパターンをログに出すことで再現性が高まります。

オンラインツールとの併用

ログのパターンやマッチ文字列をコピーして、Regex101などのツールで検証すると効率的です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"(\d+";
        string input = "12345";
        try
        {
            Regex.Replace(input, pattern, "#");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"パターン: {pattern}");
            Console.WriteLine($"例外メッセージ: {ex.Message}");
        }
    }
}

パターン: (\d+
例外メッセージ: Invalid pattern '(\d+' at offset 4. Not enough )'s.

このように、エラー発生時にパターンと例外内容をログに残すことで、問題の特定と修正がスムーズになります。

ユースケース別サンプル

正規表現の置換機能はさまざまな場面で活用できます。

ここでは、実務でよくあるユースケースを例に、具体的なC#コードとともに紹介します。

設定ファイルのキー置換

設定ファイルの中で特定のキーの値を一括で置換したい場合に便利です。

例えば、config.iniのような形式で、特定のキーの値だけを変更するケースです。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string config = @"
[Database]
Host=localhost
Port=5432
User=admin
Password=secret
";
        string keyToReplace = "Password";
        string newValue = "new_secret";
        // キーと値のペアをマッチする正規表現
        string pattern = $@"^{keyToReplace}=(.*)$";
        string result = Regex.Replace(config, pattern, $"{keyToReplace}={newValue}", RegexOptions.Multiline);
        Console.WriteLine(result);
    }
}

[Database]
Host=localhost
Port=5432
User=admin
Password=new_secret

この例では、^Password=(.*)$というパターンでPasswordキーの行を検出し、値を新しいものに置換しています。

RegexOptions.Multilineを指定することで、複数行の中から行単位でマッチさせています。

ログマスク処理

ログに含まれる個人情報や機密情報をマスクする処理も正規表現置換でよく行われます。

例えば、電話番号やメールアドレスの一部を伏せ字にする例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string log = "User email: user@example.com, phone: 090-1234-5678";
        // メールアドレスのユーザー名部分をマスク
        string emailPattern = @"(^[\w\.-]{1})[\w\.-]+(@[\w\.-]+\.\w+)";
        string maskedLog = Regex.Replace(log, emailPattern, "$1***$2");
        // 電話番号の中央4桁をマスク
        string phonePattern = @"(\d{3})-(\d{4})-(\d{4})";
        maskedLog = Regex.Replace(maskedLog, phonePattern, "$1-****-$3");
        Console.WriteLine(maskedLog);
    }
}

User email: u***@example.com, phone: 090-****-5678

メールアドレスのユーザー名の先頭1文字だけ残し、それ以降を***に置換。

電話番号は中央の4桁をに置き換えています。

ログのプライバシー保護に役立ちます。

コード自動生成の一部置換

コード生成ツールやテンプレートで、特定のプレースホルダーを置換してコードを生成するケースです。

例えば、クラス名やメソッド名を動的に差し替えます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string template = @"
public class {{ClassName}}
{
    public void {{MethodName}}()
    {
        Console.WriteLine(""Hello from {{ClassName}}.{{MethodName}}"");
    }
}
";
        var replacements = new System.Collections.Generic.Dictionary<string, string>
        {
            { "ClassName", "MyClass" },
            { "MethodName", "MyMethod" }
        };
        string pattern = @"\{\{(\w+)\}\}";
        string result = Regex.Replace(template, pattern, match =>
        {
            string key = match.Groups[1].Value;
            return replacements.ContainsKey(key) ? replacements[key] : match.Value;
        });
        Console.WriteLine(result);
    }
}

public class MyClass
{
    public void MyMethod()
    {
        Console.WriteLine("Hello from MyClass.MyMethod");
    }
}

{{ClassName}}や{{MethodName}}のようなプレースホルダーを正規表現で検出し、辞書の値で置換しています。

動的なコード生成に便利です。

テンプレートエンジン風加工

HTMLやメールテンプレートなどで、変数を埋め込む処理も正規表現置換で実装可能です。

例えば、{{name}}のような変数を実際の値に置き換えます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string template = "こんにちは、{{name}}さん。今日は{{day}}です。";
        var values = new System.Collections.Generic.Dictionary<string, string>
        {
            { "name", "太郎" },
            { "day", "月曜日" }
        };
        string pattern = @"\{\{(\w+)\}\}";
        string result = Regex.Replace(template, pattern, match =>
        {
            string key = match.Groups[1].Value;
            return values.ContainsKey(key) ? values[key] : match.Value;
        });
        Console.WriteLine(result);
    }
}

こんにちは、太郎さん。今日は月曜日です。

テンプレート内の変数を辞書の値で置換し、簡易的なテンプレートエンジンとして機能させています。

多言語対応文字列の切り替え

多言語対応のアプリケーションで、言語ごとに文字列を切り替える処理も正規表現置換で実装できます。

例えば、特定のタグで囲まれた部分を言語別の文字列に置換します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Welcome! <lang:en>Hello</lang> <lang:ja>こんにちは</lang>";
        string targetLang = "ja";
        string pattern = @"<lang:(\w+)>(.*?)</lang>";
        string result = Regex.Replace(input, pattern, match =>
        {
            string lang = match.Groups[1].Value;
            string text = match.Groups[2].Value;
            return lang == targetLang ? text : "";
        });
        Console.WriteLine(result.Trim());
    }
}

Welcome! こんにちは

<lang:en>, <lang:ja>のようなタグで囲まれた文字列から、指定した言語の部分だけを抽出し、それ以外は削除しています。

多言語対応のUIやコンテンツ生成に役立ちます。

テストとデバッグ方法

正規表現を使った置換処理は複雑になりやすいため、テストとデバッグをしっかり行うことが重要です。

ここでは、C#でのユニットテストフレームワークxUnitの活用方法、オンラインツールRegex101の使い方、さらにフェイクデータ生成とテストカバレッジの確保について解説します。

xUnitを使ったユニットテスト

xUnitは.NETで広く使われているユニットテストフレームワークです。

正規表現の置換処理もユニットテストで検証することで、意図した動作を保証しやすくなります。

以下は、Regex.Replaceを使った置換処理のテスト例です。

using System.Text.RegularExpressions;
using Xunit;
public class RegexReplaceTests
{
    [Theory]
    [InlineData("Samurai123Engineer", @"\d+", "", "SamuraiEngineer")]
    [InlineData("2024-06-15", @"(\d{4})-(\d{2})-(\d{2})", "$1年$2月$3日", "2024年06月15日")]
    [InlineData("user@example.com", @"(^[\w\.-]{1})[\w\.-]+(@[\w\.-]+\.\w+)", "$1***$2", "u***@example.com")]
    public void Replace_ShouldReturnExpectedResult(string input, string pattern, string replacement, string expected)
    {
        string actual = Regex.Replace(input, pattern, replacement);
        Assert.Equal(expected, actual);
    }
}

このコードでは、[Theory]属性と[InlineData]で複数のテストケースをまとめて実行しています。

Regex.Replaceの結果が期待値と一致するかをAssert.Equalで検証しています。

xUnitはVisual Studioのテストエクスプローラーやコマンドラインから実行可能で、CI/CDパイプラインにも組み込みやすいです。

Regex101などツールの活用

正規表現のパターン作成やデバッグには、オンラインツールの活用が非常に効果的です。

特にRegex101は以下の特徴があります。

パターンのリアルタイムマッチング表示
マッチした部分やキャプチャグループの詳細表示
置換文字列のテスト機能
正規表現の説明やエラー表示
C#を含む複数言語の正規表現サポート

例えば、Regex101に以下のようなパターンとテキストを入力すると、どの部分がマッチしているか、キャプチャグループの内容、置換結果を即座に確認できます。

パターン: (\d{4})-(\d{2})-(\d{2})
テキスト: 2024-06-15
置換: $1年$2月$3日

これにより、C#のRegex.Replaceで使うパターンや置換文字列の動作を事前に検証でき、バグの早期発見につながります。

フェイクデータ生成とテストカバレッジ

正規表現のテストでは、さまざまな入力パターンを網羅することが重要です。

特に実際の運用で想定される多様なデータを用意することで、予期せぬ不具合を防げます。

フェイクデータ生成

BogusやAutoFixtureなどのライブラリを使うと、メールアドレスや電話番号、日付などのフェイクデータを大量に生成できます。

これを使って正規表現のテストケースを増やすことが可能です。

using Bogus;
using Xunit;
using System.Text.RegularExpressions;
public class RegexFakerTests
{
    [Fact]
    public void EmailMasking_ShouldWorkForVariousEmails()
    {
        var faker = new Faker();
        var emailPattern = @"(^[\w\.-]{1})[\w\.-]+(@[\w\.-]+\.\w+)";
        var maskReplacement = "$1***$2";
        for (int i = 0; i < 100; i++)
        {
            string email = faker.Internet.Email();
            string masked = Regex.Replace(email, emailPattern, maskReplacement);
            Assert.StartsWith(email[0].ToString(), masked);
            Assert.Contains("***", masked);
            Assert.EndsWith(email.Substring(email.IndexOf('@')), masked);
        }
    }
}

テストカバレッジの確保

ユニットテストの実行時にカバレッジツール(Visual Studioのカバレッジ機能やcoverletなど)を使い、正規表現を含むコードが十分にテストされているか確認します。

カバレッジが低い部分は追加テストを検討しましょう。

境界値や異常系のテスト

空文字、特殊文字、長大な文字列、パターンにマッチしない文字列などもテストケースに含めることで、堅牢な正規表現処理を実現できます。

これらの方法を組み合わせてテストを充実させることで、正規表現置換の信頼性を高められます。

メンテナンスしやすいコード設計

正規表現は強力ですが、複雑なパターンになると可読性や保守性が低下しやすいです。

長期的にメンテナンスしやすいコードを書くためには、正規表現の管理方法やコメントの付け方、アセンブリ境界の設計などに工夫が必要です。

正規表現を定数化するメリット

正規表現パターンをコード中に直接埋め込むと、複数箇所で同じパターンを使う場合に修正漏れが発生しやすくなります。

そこで、パターンを定数としてまとめて管理する方法が有効です。

public static class RegexPatterns
{
    public const string DatePattern = @"(\d{4})-(\d{2})-(\d{2})";
    public const string EmailPattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
    public const string PhonePattern = @"\d{3}-\d{4}-\d{4}";
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "2024-06-15";
        string result = Regex.Replace(input, RegexPatterns.DatePattern, "$1年$2月$3日");
        Console.WriteLine(result);
    }
}

2024年06月15日

メリット

一元管理

パターンを一箇所にまとめることで、修正や更新が容易になります。

再利用性向上

複数のクラスやメソッドで同じパターンを使う際に重複を避けられます。

可読性の向上

意味のある名前を付けることで、パターンの役割が明確になります。

テストの効率化

パターン単位でのテストや検証がしやすくなります。

コメントとReadableRegexの導入

正規表現は一見して意味が分かりにくいため、コメントを付けることが重要です。

C#のRegexクラスはRegexOptions.IgnorePatternWhitespaceを使うことで、パターン内に空白やコメントを入れられます。

string pattern = @"
    ^                   # 行頭
    (\d{4})             # 年(4桁)

    -                   # 区切り文字

    (\d{2})             # 月(2桁)

    -                   # 区切り文字

    (\d{2})             # 日(2桁)
    $                   # 行末
";
var regex = new Regex(pattern, RegexOptions.IgnorePatternWhitespace);

このように改行やコメントを入れることで、パターンの構造が理解しやすくなります。

さらに、ReadableRegexというNuGetパッケージを使うと、より直感的に正規表現を記述できます。

例えば、以下のようにビルダー形式でパターンを組み立てられます。

using ReadableRegex;
var pattern = new RegexBuilder()
    .StartOfLine()
    .Capture(new Digit().Repeat(4))  // 年
    .Literal("-")
    .Capture(new Digit().Repeat(2))  // 月
    .Literal("-")
    .Capture(new Digit().Repeat(2))  // 日
    .EndOfLine()
    .ToRegex();
string input = "2024-06-15";
string result = pattern.Replace(input, "$1年$2月$3日");
Console.WriteLine(result);

2024年06月15日

メリット

パターンの意味がコードとして明示されるため、可読性が大幅に向上します
複雑な正規表現の保守が楽になります
コメントや空白の扱いを気にせずに済みます

アセンブリ境界の設計

大規模なプロジェクトでは、正規表現を使った処理をどのアセンブリ(ライブラリ)に配置するかも重要です。

以下のポイントを考慮してください。

正規表現の共通ライブラリ化

複数のプロジェクトやモジュールで使う正規表現は共通ライブラリにまとめると、重複を避けてメンテナンスしやすくなります。

依存関係の整理

正規表現を使うコードが特定のドメインロジックに依存しないように分離し、アセンブリ間の依存関係をシンプルに保ちます。

バージョン管理とリリース

正規表現パターンの変更が他のモジュールに影響を与える場合があるため、共通ライブラリのバージョン管理を厳密に行い、リリース時の影響範囲を把握します。

テストの集中管理

共通ライブラリに正規表現のテストコードもまとめることで、品質管理がしやすくなります。

これらの設計を意識することで、正規表現を含むコードの拡張や修正がスムーズになり、チーム開発でもトラブルを減らせます。

セキュリティの考慮事項

正規表現を使った文字列置換は便利ですが、セキュリティ面でのリスクも存在します。

特にユーザー入力を直接パターンに組み込むことや、ReDoS(正規表現によるサービス拒否攻撃)、個人情報の漏えい防止などに注意が必要です。

ユーザー入力をパターンに組み込まない

ユーザーからの入力をそのまま正規表現のパターンに組み込むと、意図しない動作やセキュリティリスクが発生します。

例えば、ユーザーが特殊文字や正規表現のメタ文字を含む文字列を送信すると、パターンが破壊されたり、予期しないマッチングが起きたりします。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string userInput = ".*"; // ユーザーが入力した文字列(メタ文字を含む)
        string pattern = $"^{userInput}$"; // 直接パターンに組み込むと危険
        string test = "anything";
        bool isMatch = Regex.IsMatch(test, pattern);
        Console.WriteLine(isMatch); // 予期せずTrueになる可能性がある
    }
}

この例では、ユーザー入力が.*のため、どんな文字列にもマッチしてしまいます。

これにより、意図しないマッチングや情報漏えいの原因となることがあります。

ユーザー入力をパターンに組み込む場合は、必ずRegex.Escapeでエスケープしてメタ文字を無効化します

string safeInput = Regex.Escape(userInput);
string safePattern = $"^{safeInput}$";

可能な限り、ユーザー入力はパターンではなく置換文字列やマッチ対象の文字列として扱います
ユーザー入力を正規表現のパターンとして使う必要がある場合は、入力の検証や制限を厳格に行います

ReDoS対策とタイムアウト

ReDoS(Regular Expression Denial of Service)は、複雑な正規表現パターンに対して悪意のある入力を与え、過剰なバックトラックを発生させて処理を遅延させる攻撃です。

これにより、サービスが応答不能になるリスクがあります。

string pattern = @"(a+)+b";
string input = new string('a', 10000); // 大量の'a'のみの文字列
// このパターンと入力はバックトラック爆発を引き起こす可能性がある

複雑なネストした繰り返しを避けます。例えば、(a+)+のようなパターンは単純化します
Regexのコンストラクタでタイムアウトを設定し、一定時間を超えた処理は例外で中断します

var regex = new Regex(pattern, RegexOptions.None, TimeSpan.FromSeconds(1));
try
{
    regex.IsMatch(input);
}
catch (RegexMatchTimeoutException)
{
    Console.WriteLine("正規表現の処理がタイムアウトしました。");
}

入力の長さや内容を事前に検証し、異常に長い文字列や疑わしいパターンを拒否します
可能であれば、ReDoS耐性のある正規表現エンジンやライブラリを利用します

データ漏えい防止のマスキング処理

ログや画面表示に個人情報や機密情報が含まれる場合、正規表現を使ってマスキング処理を行い、情報漏えいを防止します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string log = "User email: user@example.com, phone: 090-1234-5678";
        // メールアドレスのユーザー名部分をマスク
        string emailPattern = @"(^[\w\.-]{1})[\w\.-]+(@[\w\.-]+\.\w+)";
        string maskedLog = Regex.Replace(log, emailPattern, "$1***$2");
        // 電話番号の中央4桁をマスク
        string phonePattern = @"(\d{3})-(\d{4})-(\d{4})";
        maskedLog = Regex.Replace(maskedLog, phonePattern, "$1-****-$3");
        Console.WriteLine(maskedLog);
    }
}

User email: u***@example.com, phone: 090-****-5678

ポイント

マスキングは必要な情報を残しつつ、個人を特定できる部分を隠すことが重要です
ログや画面表示だけでなく、外部に送信するデータにもマスキングを適用します
マスキング処理の正規表現はテストを十分に行い、漏れや誤検知がないようにします
マスキング対象のパターンは定数化し、変更時に一元管理できるようにします

これらのセキュリティ対策を正規表現置換処理に組み込むことで、安全かつ信頼性の高いシステムを構築できます。

.NETバージョンごとの違い

C#の正規表現機能は.NET Frameworkから.NET Core、そして.NET 5以降へと進化しており、バージョンごとに性能や機能面での違いがあります。

ここでは、主要な違いと新機能について解説します。

.NET Frameworkと.NET Core

.NET FrameworkはWindows向けのフルフレームワークで、長年にわたり安定した正規表現機能を提供してきました。

一方、.NET Coreはクロスプラットフォーム対応を目指して設計され、パフォーマンスやAPIの改善が進められています。

パフォーマンスの違い

.NET Coreでは正規表現エンジンの内部実装が最適化されており、.NET Frameworkに比べて高速化が図られています。

特にRegexOptions.Compiledの効果が高く、マルチプラットフォーム環境での動作も安定しています。

APIの互換性

基本的なRegexクラスのAPIはほぼ同じですが、一部のオプションや挙動に微妙な差異がある場合があります。

例えば、タイムアウト機能は.NET Framework 4.5以降で導入されましたが、.NET Coreではより厳密にサポートされています。

Unicodeサポート

.NET CoreはUnicodeの扱いが強化されており、多言語対応の正規表現処理がより正確に行えます。

.NET 5以降のRegex新機能

.NET 5は.NET Coreの後継として統合されたプラットフォームで、正規表現機能もさらに進化しています。

Regexパフォーマンスの向上

.NET 5以降では、正規表現のパフォーマンスがさらに改善され、特に大規模テキストのマッチングや置換処理で高速化が実現されています。

タイムアウトの強化

タイムアウト機能がより堅牢になり、ReDoS攻撃対策としての信頼性が向上しています。

Span<char>対応

.NET 5以降はSpan<char>を使った正規表現APIが導入され、メモリ効率が大幅に改善されました。

これにより、文字列のコピーを減らし、パフォーマンスとメモリ使用量の最適化が可能です。

新しいAPIの追加

例えば、Regex.Match(ReadOnlySpan<char>)やRegex.Replace(ReadOnlySpan<char>, ...)など、Spanを活用したオーバーロードが追加されています。

RegexGenerator属性の導入

.NET 7で導入された大きな新機能の一つが、RegexGenerator属性によるソースジェネレーター対応です。

概要

RegexGenerator属性を使うと、コンパイル時に正規表現のコードが自動生成され、実行時のパターン解析やコンパイルが不要になります。

これにより、起動時間の短縮と実行時パフォーマンスの大幅な向上が期待できます。

使い方の例

using System.Text.RegularExpressions;
[GeneratedRegex(@"\d+")]
partial class DigitRegex
{
}
class Program
{
    static void Main()
    {
        var regex = new DigitRegex();
        string input = "abc123def456";
        string result = regex.Replace(input, "#");
        Console.WriteLine(result); // 出力: abc#def#
    }
}

メリット
- 実行時の正規表現コンパイルコストがゼロになる
- 高速なマッチングと置換が可能
- コードの安全性と可読性が向上
注意点
- .NET 7以降でのみ利用可能
- ソースジェネレーターの仕組みを理解しておく必要がある

この機能はパフォーマンスクリティカルなアプリケーションや大量の正規表現処理を行うシステムで特に有効です。

これらのバージョンごとの違いを理解し、プロジェクトの要件に応じて適切な.NETバージョンと正規表現機能を選択することが重要です。

正規表現を使う際に開発者からよく寄せられる疑問や問題点について、具体的な解決策やポイントを解説します。

正規表現が複雑化した場合の分割方法

複雑な正規表現は可読性や保守性が低下し、バグの温床になりやすいです。

分割して管理する方法として以下のアプローチがあります。

複数の小さなパターンに分割して組み合わせる

例えば、部分的なパターンを変数や定数に分けておき、最終的に連結して使う方法です。

const string year = @"\d{4}";
const string month = @"\d{2}";
const string day = @"\d{2}";
string pattern = $@"^{year}-{month}-{day}$";

名前付きキャプチャグループで意味を明確にする

複雑なパターンでも名前付きキャプチャを使うと、どの部分が何を表しているか分かりやすくなります。

string pattern = @"^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$";

コメント付き正規表現を使う

RegexOptions.IgnorePatternWhitespaceを指定し、パターン内に改行やコメントを入れて読みやすくします。

string pattern = @"
    ^                   # 行頭
    (?<year>\d{4})      # 年

    -                   # 区切り

    (?<month>\d{2})     # 月

    -                   # 区切り

    (?<day>\d{2})       # 日
    $                   # 行末
";
var regex = new Regex(pattern, RegexOptions.IgnorePatternWhitespace);

MatchEvaluatorや複数段階の置換を活用する

一度に複雑な置換を行うのではなく、段階的に複数回の置換処理に分けることで管理しやすくなります。

大文字小文字の無視はどこで指定するか

正規表現で大文字小文字を区別せずにマッチさせたい場合は、RegexOptions.IgnoreCaseオプションを指定します。

これはRegexのコンストラクタやRegex.Replaceのオーバーロードで渡せます。

string input = "Hello World";
string pattern = "hello";
string result = Regex.Replace(input, pattern, "Hi", RegexOptions.IgnoreCase);
Console.WriteLine(result); // 出力: Hi World

また、パターン内で大文字小文字無視を指定することも可能ですが、C#のRegexではオプション指定が一般的です。

まとめ

指定方法	使いどころ
`RegexOptions.IgnoreCase`	置換やマッチ時に大文字小文字無視したい場合
パターン内のフラグ(例: `(?i)`)	一部の正規表現エンジンで利用可能(C#では非推奨)

C#ではRegexOptions.IgnoreCaseを使うのが最も確実でわかりやすい方法です。

CultureInfo の影響

正規表現のマッチングは文化依存の文字列比較に影響を受けることがあります。

特に大文字小文字の比較や文字クラスの解釈にCultureInfoが関係します。

RegexOptions.CultureInvariant

このオプションを指定すると、文化依存しない比較が行われ、どの環境でも同じ結果が得られます。

多言語対応やグローバルなアプリケーションでは推奨されます。

string input = "straße";
string pattern = "STRASSE";
bool matchDefault = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
bool matchInvariant = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
Console.WriteLine(matchDefault);   // 環境によってTrue/Falseが変わる可能性あり
Console.WriteLine(matchInvariant); // 常にFalse(文化依存しない比較)

文化依存の例

ドイツ語のßは大文字化するとSSになるため、文化依存の比較ではマッチする場合がありますが、文化非依存ではマッチしません。

まとめ

オプション	説明
なし(デフォルト)	実行環境のカルチャに依存した比較を行う
`RegexOptions.CultureInvariant`	文化依存しない比較を行い、一貫性を保つ