文字列

【C#】Regex.IsMatchで簡単正規表現チェック—基礎からエラー対策・高速化まで一気にわかる

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

C#で文字列がパターンに合うか確かめるならRegex.IsMatchが最速の近道です。

逐語的文字列リテラル@を付ければバックスラッシュの煩わしさを減らせ、オプション引数で大文字小文字や複数行にも柔軟に対応可能です。

入力が不正でも例外は出ないのでMatch.Successや戻り値で即判定でき、前後処理は不要。

速度重視なら事前にRegexをコンパイルし再利用するとGC負荷も抑えられます。

目次から探す

正規表現チェックの基本
- Regex.IsMatchが担う役割
- パターンマッチの流れ
Regex.IsMatchのシグネチャと主要オーバーロード
正規表現パターン設計の基礎
高度なマッチング
RegexOptionsの使いこなし
実用シナリオ別サンプル
例外とエラー対策
パフォーマンス最適化
テストと検証
デバッグとチューニング
外部ツールと支援サービス
代替アプローチ
保守性を高める設計
まとめ

正規表現チェックの基本

Regex.IsMatchが担う役割

C#で文字列が特定のパターンに合致するかどうかを判定する際に、最も手軽に使えるメソッドがRegex.IsMatchです。

このメソッドは、System.Text.RegularExpressions名前空間に属するRegexクラスの静的メソッドで、指定した文字列が正規表現パターンにマッチするかどうかを真偽値で返します。

Regex.IsMatchの主な役割は、文字列の中にパターンに合致する部分が存在するかを高速かつ簡単に判定することです。

例えば、メールアドレスの形式チェックやファイル名の拡張子判定、電話番号のフォーマット確認など、さまざまな場面で活用できます。

このメソッドは、マッチした部分の詳細な情報を必要としない場合に特に有効です。

マッチの有無だけを知りたいときに使うことで、コードがシンプルになり、パフォーマンスも向上します。

以下は、Regex.IsMatchの基本的な使い方の例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "example@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$"; // 簡易的なメールアドレスの正規表現
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、input文字列がメールアドレスの形式に合致するかどうかを判定しています。

Regex.IsMatchは、パターンに合致すればtrueを返し、そうでなければfalseを返します。

パターンマッチの流れ

Regex.IsMatchが内部でどのように動作しているかを理解すると、正規表現の設計やパフォーマンス改善に役立ちます。

ここでは、パターンマッチの基本的な流れを解説します。

正規表現パターンのコンパイル

Regex.IsMatchに渡された正規表現パターンは、まず内部で解析され、正規表現エンジンが理解できる形式に変換されます。

これを「コンパイル」と呼びます。

文字列リテラルでパターンを指定するときは、エスケープ文字の扱いに注意が必要です。

例えば、\d(数字を表す)を文字列内で使う場合は、@"\d"のように逐語的文字列リテラルを使うとわかりやすくなります。

入力文字列の走査

コンパイルされたパターンを使って、入力文字列の先頭から順にパターンに合致する部分があるかを調べます。

Regex.IsMatchは、最初にマッチした時点で処理を終了し、trueを返します。

マッチしなければ文字列の末尾まで調べてfalseを返します。

マッチ結果の返却

マッチが成功した場合はtrue、失敗した場合はfalseを返します。

Regex.IsMatchはマッチした部分の詳細情報を返さないため、単純に「合致したかどうか」の判定に特化しています。

この流れを踏まえると、Regex.IsMatchは「パターンに合致するかどうかだけを知りたい」ケースに最適です。

もしマッチした部分の文字列や位置を取得したい場合は、Regex.MatchやRegex.Matchesを使う必要があります。

以下は、Regex.IsMatchのパターンマッチの流れを示す簡単なサンプルです。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "file123.txt";
        string pattern = @"file\d+\.txt"; // fileに続く数字と.txtで終わるパターン
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、input文字列がfileに数字が続き、.txtで終わるかどうかを判定しています。

Regex.IsMatchは、パターンに合致する部分があればすぐにtrueを返します。

Regex.IsMatchは、正規表現を使った文字列チェックの基本中の基本です。

パターンの設計や使い方を理解することで、より効率的で安全な文字列検証が可能になります。

Regex.IsMatchのシグネチャと主要オーバーロード

引数が最小の形

Regex.IsMatchの最もシンプルな使い方は、文字列と正規表現パターンの2つの引数を渡す形です。

このオーバーロードは、正規表現のオプションを指定せず、文字列全体に対してパターンマッチを行います。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "hello123";
        string pattern = @"hello\d+";
        bool result = Regex.IsMatch(input, pattern);
        Console.WriteLine(result); // 結果: True
    }
}

この例では、inputがhelloに続いて1つ以上の数字で終わるかどうかを判定しています。

Regex.IsMatchは、パターンに合致すればtrueを返し、そうでなければfalseを返します。

このシグネチャの特徴は、簡潔で使いやすいことです。

正規表現のオプションを指定しないため、デフォルトの設定(大文字・小文字を区別し、複数行モードは無効など)でマッチングが行われます。

RegexOptionsを伴う形

正規表現の動作を細かく制御したい場合は、RegexOptions列挙体を引数に追加するオーバーロードを使います。

これにより、大文字・小文字の区別を無視したり、複数行モードを有効にしたり、正規表現のコンパイルを行うなどの設定が可能です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "HELLO123";
        string pattern = @"hello\d+";
        // 大文字・小文字を区別しないマッチングを指定
        bool result = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(result); // 結果: True
    }
}

この例では、RegexOptions.IgnoreCaseを指定しているため、inputの大文字表記でもパターンにマッチしています。

主なRegexOptionsの例を以下に示します。

オプション名	説明
IgnoreCase	大文字・小文字を区別しない
Multiline	`^`と`$`が行の先頭・末尾にマッチする
Singleline	`.`が改行文字にもマッチする
Compiled	正規表現をコンパイルして高速化
CultureInvariant	文化依存の比較を無効にする
ExplicitCapture	名前付きキャプチャ以外のキャプチャを無効にする
IgnorePatternWhitespace	パターン内の空白やコメントを無視する

これらのオプションを組み合わせて使うことも可能です。

開始位置を指定する形

文字列の特定の位置からマッチングを開始したい場合は、開始位置を指定できるオーバーロードを使います。

これにより、文字列の一部だけを対象に正規表現を適用できます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123def456";
        string pattern = @"\d+";
        // 文字列の6文字目(インデックス5)からマッチング開始
        bool result = Regex.IsMatch(input, pattern, RegexOptions.None, 5);
        Console.WriteLine(result); // 結果: True
    }
}

この例では、inputの6文字目(0ベースのインデックス5)から数字の連続にマッチするかを判定しています。

"def456"の部分に数字が含まれているため、trueが返ります。

開始位置を指定することで、文字列の先頭からではなく、任意の位置からパターンマッチを行いたい場合に便利です。

例えば、ログファイルの特定の位置以降だけを検査したいときなどに活用できます。

これらのオーバーロードを使い分けることで、Regex.IsMatchの柔軟な利用が可能になります。

用途に応じて適切なシグネチャを選択してください。

正規表現パターン設計の基礎

エスケープ文字の扱い

正規表現では、特定の文字がメタ文字として特別な意味を持ちます。

例えば、.(任意の1文字)、*(直前の文字の0回以上の繰り返し)、+(1回以上の繰り返し)などです。

これらの文字を文字通りに扱いたい場合は、エスケープ文字であるバックスラッシュ\を使ってエスケープします。

例えば、ドット.を文字としてマッチさせたい場合は、\.と記述します。

C#の文字列リテラル内でバックスラッシュを使う場合は、さらにエスケープが必要になるため、"\\."のように書くか、逐語的文字列リテラル(@を付ける)を使って@"\."と書くのが一般的です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "file.txt";
        string pattern = @"file\.txt"; // ドットを文字として扱う
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、file.txtという文字列がfile.txtというパターンにマッチしています。

もしドットをエスケープしなければ、.は任意の1文字として解釈され、fileXtxtのような文字列にもマッチしてしまいます。

文字クラスとショートカット

文字クラスは、角括弧[]で囲んだ中にマッチさせたい文字の集合を指定します。

例えば、[abc]はa、b、cのいずれか1文字にマッチします。

範囲指定も可能で、[a-z]は小文字のアルファベット1文字にマッチします。

複数の範囲や文字を組み合わせることもできます。

また、文字クラスには否定もあり、[^0-9]は数字以外の1文字にマッチします。

正規表現にはよく使われる文字クラスのショートカットもあります。

ショートカット	意味
`\d`	数字`[0-9]`
`\D`	数字以外`[^0-9]`
`\w`	単語構成文字(英数字とアンダースコア、`[a-zA-Z0-9_]`)
`\W`	単語構成文字以外
`\s`	空白文字(スペース、タブ、改行など)
`\S`	空白文字以外

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123";
        string pattern = @"[a-z]+\d+"; // 小文字の連続 + 数字の連続
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、小文字アルファベットが1文字以上続き、その後に数字が1文字以上続く文字列にマッチします。

量指定子と貪欲・非貪欲

量指定子は、直前の文字やグループが何回繰り返されるかを指定します。

主な量指定子は以下の通りです。

量指定子	意味
`*`	0回以上の繰り返し(貪欲)
`+`	1回以上の繰り返し(貪欲)
`?`	0回か1回の出現(貪欲)
`{n}`	ちょうどn回の繰り返し
`{n,}`	n回以上の繰り返し
`{n,m}`	n回以上m回以下の繰り返し

量指定子はデフォルトで「貪欲(Greedy)」です。

つまり、可能な限り多くの文字にマッチしようとします。

非貪欲(Lazy)にしたい場合は、量指定子の後に?を付けます。

例えば、*?や+?です。

非貪欲は、最小限の文字数にマッチします。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "<div>content</div><div>more</div>";
        string patternGreedy = @"<div>.*</div>";
        string patternLazy = @"<div>.*?</div>";
        bool greedyMatch = Regex.IsMatch(input, patternGreedy);
        bool lazyMatch = Regex.IsMatch(input, patternLazy);
        Console.WriteLine($"貪欲マッチ: {greedyMatch}"); // True
        Console.WriteLine($"非貪欲マッチ: {lazyMatch}"); // True
        // 実際のマッチ内容を確認
        var matchGreedy = Regex.Match(input, patternGreedy);
        var matchLazy = Regex.Match(input, patternLazy);
        Console.WriteLine($"貪欲マッチ内容: {matchGreedy.Value}");
        Console.WriteLine($"非貪欲マッチ内容: {matchLazy.Value}");
    }
}

貪欲マッチ: True
非貪欲マッチ: True
貪欲マッチ内容: <div>content</div><div>more</div>
非貪欲マッチ内容: <div>content</div>

この例では、貪欲な.*は可能な限り多くの文字をマッチし、2つの<div>タグをまとめてマッチさせています。

一方、非貪欲な.*?は最小限の文字数でマッチし、最初の<div>タグだけにマッチしています。

アンカーと境界

アンカーは文字列の特定の位置にマッチさせるためのメタ文字です。

主なアンカーは以下の通りです。

アンカー	意味
`^`	文字列の先頭(`RegexOptions.Multiline`で行頭)
`$`	文字列の末尾(`RegexOptions.Multiline`で行末)
`\b`	単語の境界(単語文字と非単語文字の間)
`\B`	単語の境界以外の位置

例えば、文字列の先頭にHelloがあるかを判定するには、^Helloを使います。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Hello World";
        string pattern = @"^Hello";
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

単語の境界\bは、単語単位の検索に便利です。

例えば、catという単語だけにマッチさせたい場合は、\bcat\bと書きます。

グループ化とネスト

正規表現では、丸括弧()を使って部分パターンをグループ化できます。

グループ化は、量指定子の適用範囲を限定したり、マッチした部分を後で参照したりする際に使います。

グループはネスト(入れ子)も可能で、複雑なパターンを構築できます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"(abc)(\d+)(xyz)";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
            Console.WriteLine($"全体マッチ: {match.Value}");
            Console.WriteLine($"グループ1: {match.Groups[1].Value}");
            Console.WriteLine($"グループ2: {match.Groups[2].Value}");
            Console.WriteLine($"グループ3: {match.Groups[3].Value}");
        }
    }
}

全体マッチ: abc123xyz
グループ1: abc
グループ2: 123
グループ3: xyz

この例では、3つのグループに分けてマッチした部分を取得しています。

グループは0番が全体マッチ、1番以降が各グループに対応します。

名前付きキャプチャと参照

グループには名前を付けることもできます。

名前付きキャプチャは、グループの番号ではなく名前でアクセスできるため、可読性が向上します。

名前付きキャプチャは(?<名前>パターン)の形式で記述します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "2023-06-15";
        string pattern = @"(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
            Console.WriteLine($"年: {match.Groups["year"].Value}");
            Console.WriteLine($"月: {match.Groups["month"].Value}");
            Console.WriteLine($"日: {match.Groups["day"].Value}");
        }
    }
}

年: 2023
月: 06
日: 15

名前付きキャプチャは、後方参照(パターン内で同じ文字列を繰り返す)にも使えます。

後方参照は\k<名前>の形式で記述します。

string pattern = @"(?<word>\w+)\s+\k<word>";

このパターンは、同じ単語が2回連続している場合にマッチします。

非キャプチャグループ

グループ化は便利ですが、すべてのグループがキャプチャ(マッチした部分を記憶)されると、パフォーマンスに影響が出る場合があります。

キャプチャが不要な場合は、非キャプチャグループを使います。

非キャプチャグループは(?:パターン)の形式で記述し、マッチはするもののキャプチャはされません。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "color";
        string pattern = @"colou?r"; // uは0回か1回
        // 非キャプチャグループを使った例
        string patternNonCapture = @"col(?:ou)?r";
        bool isMatch = Regex.IsMatch(input, patternNonCapture);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、uの有無を非キャプチャグループで指定しています。

キャプチャしないため、グループ番号は増えず、パフォーマンスが向上します。

これらの基礎を押さえることで、正規表現パターンを効率的かつ読みやすく設計できます。

特にグループ化や量指定子の使い方は、複雑なパターンを扱う際に重要です。

高度なマッチング

先読み・後読み

先読み(Lookahead)と後読み(Lookbehind)は、特定のパターンの前後に別のパターンが存在するかどうかを条件としてマッチングを行うテクニックです。

これらは「ゼロ幅アサーション」と呼ばれ、マッチ対象の文字列自体には含まれず、条件判定だけに使われます。

先読み(Lookahead)

先読みは、あるパターンの直後に特定のパターンが続くかどうかを判定します。

書式は以下の通りです。

肯定の先読みです：(?=パターン)
否定の先読みです：(?!パターン)

例として、数字の後にUSDが続く場合にマッチさせるパターンを示します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "100USD 200JPY 300USD";
        string pattern = @"\d+(?=USD)";
        MatchCollection matches = Regex.Matches(input, pattern);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}

100
300

この例では、数字の後にUSDが続く部分だけを抽出しています。

(?=USD)はUSDが直後にあることを条件にしていますが、マッチ結果には含まれません。

後読み(Lookbehind)

後読みは、あるパターンの直前に特定のパターンが存在するかを判定します。

書式は以下の通りです。

肯定の後読みです：(?<=パターン)
否定の後読みです：(?<!パターン)

例えば、USDの前に数字がある部分を抽出する例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "100USD 200JPY 300USD";
        string pattern = @"(?<=\d)USD";
        MatchCollection matches = Regex.Matches(input, pattern);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}

USD
USD

この例では、数字の直後にあるUSDだけがマッチしています。

後読みはマッチ対象の前の条件を指定するのに便利です。

バックトラッキング抑制

正規表現は複雑なパターンでマッチングを試みる際に、バックトラッキングという処理を行います。

これは、マッチに失敗した場合にパターンの別の解釈を試す動作で、場合によってはパフォーマンス低下やタイムアウトの原因になります。

バックトラッキングを抑制するには、否定的先読みや非貪欲量指定子の活用、そしてatomic group(アトミックグループ)やpossessive quantifiers(所有的量指定子)を使う方法があります。

C#のRegexでは所有的量指定子はサポートされていませんが、アトミックグループは(?>...)で表現できます。

アトミックグループの例

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "aaaaab";
        string patternBacktracking = @"a+a+b";
        string patternAtomic = @"(?>a+)a+b";
        bool matchBacktracking = Regex.IsMatch(input, patternBacktracking);
        bool matchAtomic = Regex.IsMatch(input, patternAtomic);
        Console.WriteLine($"バックトラッキングあり: {matchBacktracking}");
        Console.WriteLine($"アトミックグループ使用: {matchAtomic}");
    }
}

バックトラッキングあり: True
アトミックグループ使用: False

この例では、a+a+bはaの繰り返しの後にa+bを探すため、バックトラッキングが発生しマッチします。

一方、アトミックグループ(?>a+)は一度マッチしたa+を再解釈しないため、後続のa+bにマッチせずfalseになります。

バックトラッキングを抑制することで、パフォーマンスの改善や意図しないマッチングの防止が可能です。

条件分岐

正規表現では、条件分岐を使ってパターンの一部を条件によって切り替えることができます。

C#のRegexでは、条件分岐は以下の形式で記述します。

(?(条件)真の場合のパターン|偽の場合のパターン)

条件には、グループの存在チェックや先読みの結果などを指定できます。

グループの存在チェックによる条件分岐の例

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input1 = "abc123";
        string input2 = "123abc";
        string pattern = @"^(?<letters>[a-z]+)?(?(letters)\d+|[a-z]+)$";
        Console.WriteLine(Regex.IsMatch(input1, pattern)); // True
        Console.WriteLine(Regex.IsMatch(input2, pattern)); // True
        Console.WriteLine(Regex.IsMatch("123", pattern));  // False
    }
}

True
True
False

このパターンは、先頭に英字のグループlettersがあれば、その後に数字が続くことを要求し、なければ英字が続くことを要求します。

input1は英字の後に数字、input2は英字がないので英字のみ、どちらもマッチしますが、"123"はマッチしません。

条件分岐を使うことで、複雑なパターンの分岐を1つの正規表現で表現できます。

Unicodeカテゴリ指定

C#の正規表現はUnicodeに対応しており、Unicodeの文字カテゴリを指定してマッチングが可能です。

\p{}構文を使い、特定のUnicodeカテゴリに属する文字を指定します。

主なUnicodeカテゴリの例は以下の通りです。

カテゴリ名	説明	例
`\p{L}`	すべての文字(Letter)	アルファベット、漢字など
`\p{Lu}`	大文字の文字	A, B, C
`\p{Ll}`	小文字の文字	a, b, c
`\p{Nd}`	10進数字	0-9
`\p{Zs}`	空白文字(スペースなど)	スペース、ノーブレークスペース

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "漢字とEnglish123";
        string pattern = @"\p{L}+";
        MatchCollection matches = Regex.Matches(input, pattern);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}

漢字とEnglish

この例では、Unicodeの文字カテゴリL(文字)にマッチする連続した部分を抽出しています。

数字や空白は含まれません。

Unicodeカテゴリを使うことで、多言語対応の文字列処理が容易になります。

特に日本語やその他の非ASCII文字を扱う場合に便利です。

RegexOptionsの使いこなし

IgnoreCaseとCultureInvariant

RegexOptions.IgnoreCaseは、正規表現のマッチング時に大文字・小文字の区別を無視するオプションです。

これを指定すると、例えば"abc"というパターンは"ABC"や"AbC"にもマッチします。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "HELLO world";
        string pattern = "hello";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、IgnoreCaseを指定しているため、大文字のHELLOにもマッチしています。

一方、RegexOptions.CultureInvariantは、文化依存の比較を無効にするオプションです。

通常、正規表現のマッチングは実行環境のカルチャ(文化)に依存する場合があります。

例えば、トルコ語のIとiの扱いなどが異なることがあります。

CultureInvariantを指定すると、カルチャに依存しない比較が行われ、環境による差異を防げます。

IgnoreCaseと組み合わせて使うことが多いです。

bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);

この組み合わせにより、どの環境でも一貫した大文字・小文字無視のマッチングが可能になります。

MultilineとSingleline

RegexOptions.Multilineは、^と$の意味を変えます。

通常、^は文字列の先頭、$は文字列の末尾にマッチしますが、Multilineを指定すると、これらは行の先頭・末尾にもマッチするようになります。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "first line\nsecond line";
        string pattern = "^second";
        bool isMatchWithoutMultiline = Regex.IsMatch(input, pattern);
        bool isMatchWithMultiline = Regex.IsMatch(input, pattern, RegexOptions.Multiline);
        Console.WriteLine(isMatchWithoutMultiline); // 結果: False
        Console.WriteLine(isMatchWithMultiline);    // 結果: True
    }
}

この例では、Multilineなしではsecondが文字列の先頭にないためマッチしませんが、Multilineを指定すると2行目の先頭にもマッチします。

一方、RegexOptions.Singlelineは、.(ドット)が改行文字にもマッチするようにします。

通常、.は改行を除く任意の1文字にマッチしますが、Singlelineを指定すると改行も含めてマッチします。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "line1\nline2";
        string pattern = "line1.line2";
        bool isMatchWithoutSingleline = Regex.IsMatch(input, pattern);
        bool isMatchWithSingleline = Regex.IsMatch(input, pattern, RegexOptions.Singleline);
        Console.WriteLine(isMatchWithoutSingleline); // 結果: False
        Console.WriteLine(isMatchWithSingleline);    // 結果: True
    }
}

この例では、改行を含む文字列に.がマッチするかどうかの違いを示しています。

Compiledと非Compiled

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

これにより、同じパターンを何度も使う場合のパフォーマンスが向上します。

using System;
using System.Text.RegularExpressions;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"\d+";
        var stopwatch = new Stopwatch();
        // 非コンパイル版
        stopwatch.Start();
        for (int i = 0; i < 100000; i++)
        {
            Regex.IsMatch(input, pattern);
        }
        stopwatch.Stop();
        Console.WriteLine($"非コンパイル: {stopwatch.ElapsedMilliseconds} ms");
        // コンパイル版
        var regexCompiled = new Regex(pattern, RegexOptions.Compiled);
        stopwatch.Restart();
        for (int i = 0; i < 100000; i++)
        {
            regexCompiled.IsMatch(input);
        }
        stopwatch.Stop();
        Console.WriteLine($"コンパイル: {stopwatch.ElapsedMilliseconds} ms");
    }
}

この例では、RegexOptions.Compiledを使った場合の方が高速に動作することが多いですが、初回のコンパイルに時間がかかるため、使いどころを考慮する必要があります。

また、Regex.IsMatchの静的メソッドは内部でキャッシュを使いますが、頻繁に異なるパターンを使う場合はCompiledオプションを付けてRegexインスタンスを作成し、使い回すのが効果的です。

ExplicitCaptureとIgnorePatternWhitespace

RegexOptions.ExplicitCaptureは、名前付きグループや番号付きグループを明示的にキャプチャする場合のみマッチ結果に含めるオプションです。

通常の丸括弧()はキャプチャグループになりますが、このオプションを指定すると、()は非キャプチャグループとして扱われ、キャプチャしたい場合は(?<name>...)や(?:...)のように明示的に指定する必要があります。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"(abc)(123)(xyz)";
        var matchDefault = Regex.Match(input, pattern);
        Console.WriteLine($"デフォルトグループ数: {matchDefault.Groups.Count}"); // 4 (全体+3グループ)
        var regexExplicit = new Regex(pattern, RegexOptions.ExplicitCapture);
        var matchExplicit = regexExplicit.Match(input);
        Console.WriteLine($"ExplicitCaptureグループ数: {matchExplicit.Groups.Count}"); // 1 (全体のみ)
    }
}

この例では、ExplicitCaptureを指定すると、丸括弧のグループはキャプチャされず、全体マッチのみが取得されます。

RegexOptions.IgnorePatternWhitespaceは、正規表現パターン内の空白文字や改行、コメントを無視するオプションです。

これにより、複雑なパターンを複数行に分けて書いたり、コメントを入れて可読性を高めたりできます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"
            (abc)    # abcにマッチ
            (\d+)    # 数字にマッチ
            (xyz)    # xyzにマッチ
        ";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnorePatternWhitespace);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、パターン内の空白やコメントが無視され、読みやすい形で正規表現を書けます。

これらのRegexOptionsを適切に使い分けることで、正規表現の動作を細かく制御し、パフォーマンスや可読性を向上させられます。

用途に応じて組み合わせて活用してください。

実用シナリオ別サンプル

ファイル拡張子判定

単一拡張子

ファイル名が特定の拡張子で終わるかどうかを判定する基本的な例です。

例えば、.txtファイルかどうかをチェックします。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string fileName = "document.txt";
        string pattern = @"\.txt$"; // 文字列の末尾が .txt であることを表す
        bool isMatch = Regex.IsMatch(fileName, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、\.txt$がファイル名の末尾に.txtがあるかを判定しています。

IgnoreCaseを指定しているため、大文字・小文字の違いは無視されます。

複数拡張子

複数の拡張子のいずれかにマッチさせたい場合は、パイプ|で区切ったグループを使います。

例えば、.txt、.doc、.pdfのいずれかで終わるかを判定します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string fileName = "report.PDF";
        string pattern = @"\.(txt|doc|pdf)$";
        bool isMatch = Regex.IsMatch(fileName, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、拡張子が.txt、.doc、.pdfのいずれかであればマッチします。

大文字・小文字の違いも無視されます。

メールアドレス検証

基本形

メールアドレスの簡単な形式チェックの例です。

@の前後に文字列があり、ドメインに.が含まれることを確認します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string email = "user@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        bool isMatch = Regex.IsMatch(email, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

このパターンは、英数字、ドット、ハイフンを含むユーザー名とドメイン名を許容し、最後にドットと文字列が続く形をチェックします。

RFC簡易準拠

RFCに準拠したメールアドレスは非常に複雑ですが、簡易的により厳密なパターンを使う例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string email = "user.name+tag+sorting@example.co.jp";
        string pattern = @"^(?("")(""[^""]+?""@)|(([0-9a-zA-Z](([\.\-\+][0-9a-zA-Z])?)*)))@([0-9a-zA-Z][\-0-9a-zA-Z]+\.)+[a-zA-Z]{2,6}$";
        bool isMatch = Regex.IsMatch(email, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

このパターンは、引用符付きのユーザー名やプラス記号を含むタグ付け、複数階層のドメイン名に対応しています。

ただし、完全なRFC準拠ではありません。

URL判定

http・https

httpまたはhttpsで始まるURLの判定例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string url = "https://www.example.com";
        string pattern = @"^https?://[\w\-]+(\.[\w\-]+)+";
        bool isMatch = Regex.IsMatch(url, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

このパターンは、httpまたはhttpsで始まり、ドメイン名が1つ以上のドット区切りで続く形をチェックします。

クエリ文字列対応

URLの末尾にクエリ文字列が付く場合も考慮した例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string url = "https://www.example.com/search?q=regex&lang=ja";
        string pattern = @"^https?://[\w\-]+(\.[\w\-]+)+(/[^\s]*)?$";
        bool isMatch = Regex.IsMatch(url, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

このパターンは、ドメインの後にスラッシュ以降の任意の文字列(クエリ文字列など)を許容しています。

電話番号・郵便番号チェック

固定電話

日本の固定電話番号の形式を簡単にチェックする例です。

市外局番が0から始まり、ハイフンで区切られているパターンを想定します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string phone = "03-1234-5678";
        string pattern = @"^0\d{1,4}-\d{1,4}-\d{4}$";
        bool isMatch = Regex.IsMatch(phone, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、市外局番が1～4桁、次の区切りも1～4桁、最後は4桁の数字で構成されていることを確認しています。

携帯電話

日本の携帯電話番号の形式をチェックする例です。

070、080、090で始まる番号を想定します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string mobile = "090-1234-5678";
        string pattern = @"^0(70|80|90)-\d{4}-\d{4}$";
        bool isMatch = Regex.IsMatch(mobile, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

このパターンは、携帯電話の代表的な番号帯にマッチします。

郵便番号

日本の郵便番号(7桁、3桁-4桁形式)をチェックする例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string postalCode = "123-4567";
        string pattern = @"^\d{3}-\d{4}$";
        bool isMatch = Regex.IsMatch(postalCode, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、3桁の数字、ハイフン、4桁の数字の形式を確認しています。

これらのサンプルは、実際の開発でよく使われる正規表現のパターン例です。

用途に応じてパターンをカスタマイズし、Regex.IsMatchで簡単に文字列の形式チェックができます。

例外とエラー対策

ArgumentExceptionの回避

ArgumentExceptionは、Regex.IsMatchやRegexクラスのコンストラクタに無効な正規表現パターンを渡した場合に発生します。

例えば、括弧の閉じ忘れや不正な量指定子など、正規表現の文法エラーが原因です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"(abc"; // 括弧の閉じ忘れ
        string input = "abc";
        try
        {
            bool isMatch = Regex.IsMatch(input, pattern);
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"正規表現の文法エラー: {ex.Message}");
        }
    }
}

正規表現の文法エラー: parsing "(abc" - Unterminated group.

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

回避策

正規表現パターンを動的に生成する場合は、パターンの構文チェックを事前に行うか、例外処理で捕捉します
静的なパターンは事前にテストツール(Regex101など)で検証します
ユーザー入力をパターンに直接使わない。必要ならエスケープ処理を行います

TimeoutExceptionの原因と防止

Regexのマッチング処理は複雑なパターンや長い入力文字列でバックトラッキングが多発すると、処理時間が膨大になり、RegexMatchTimeoutException(TimeoutExceptionの派生)が発生することがあります。

これは無限ループのように処理が長引く「正規表現の爆発的バックトラッキング」が原因です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = new string('a', 10000) + "!";
        string pattern = @"(a+)+!";
        try
        {
            bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.None, TimeSpan.FromMilliseconds(500));
        }
        catch (RegexMatchTimeoutException ex)
        {
            Console.WriteLine("マッチング処理がタイムアウトしました。");
        }
    }
}

マッチング処理がタイムアウトしました。

この例は、ネストした量指定子(a+)+が大量のaに対してバックトラッキングを引き起こし、タイムアウトしています。

防止策

複雑なパターンは避けるか、非貪欲量指定子やアトミックグループでバックトラッキングを抑制します
Regexのタイムアウトを設定し、無限ループを防ぐ
入力文字列の長さを制限します
可能なら正規表現以外の手法を検討します

RegexMatchTimeoutException実装例

RegexMatchTimeoutExceptionは、Regexのマッチング処理が指定したタイムアウト時間を超えた場合にスローされます。

これを捕捉して適切に処理する例を示します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = new string('a', 10000) + "!";
        string pattern = @"(a+)+!";
        try
        {
            bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.None, TimeSpan.FromMilliseconds(100));
            Console.WriteLine($"マッチ結果: {isMatch}");
        }
        catch (RegexMatchTimeoutException ex)
        {
            Console.WriteLine("正規表現のマッチングがタイムアウトしました。");
            Console.WriteLine($"タイムアウトしたパターン: {ex.Pattern}");
            Console.WriteLine($"タイムアウトした入力: {ex.Input.Substring(0, 20)}...");
        }
    }
}

正規表現のマッチングがタイムアウトしました。
タイムアウトしたパターン: (a+)+!
タイムアウトした入力: aaaaaaaaaaaaaaaaaaaa...

この例では、タイムアウト例外をキャッチし、原因となったパターンや入力の一部をログに出力しています。

実運用では、ユーザーにエラーメッセージを返したり、処理を中断したりする際に役立ちます。

パターンインジェクションの危険

パターンインジェクションは、ユーザー入力など外部から受け取った文字列を正規表現パターンに直接組み込むことで、意図しない正規表現の動作やセキュリティリスクを引き起こす問題です。

例えば、ユーザーが特殊文字や量指定子を含む文字列を入力し、それをパターンに埋め込むと、パターンが壊れたり、バックトラッキングが増大したりします。

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 pattern = $"^{safeInput}$";

入力値の検証や制限を行います
複雑なパターンを動的に生成しない

パターンインジェクションを防ぐことで、予期しないマッチングやパフォーマンス問題、セキュリティリスクを回避できます。

パフォーマンス最適化

静的キャッシュ

正規表現のパターンを何度も使う場合、毎回Regex.IsMatchの静的メソッドを呼ぶと内部でパターンの解析やコンパイルが繰り返され、パフォーマンスが低下します。

これを防ぐために、Regexインスタンスを静的にキャッシュして使い回す方法があります。

using System;
using System.Text.RegularExpressions;
class Program
{
    // 静的にRegexインスタンスを作成しキャッシュ
    private static readonly Regex EmailRegex = new Regex(@"^[\w\.-]+@[\w\.-]+\.\w+$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    static void Main()
    {
        string email = "user@example.com";
        bool isMatch = EmailRegex.IsMatch(email);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、EmailRegexを静的フィールドとして一度だけ生成し、複数回のマッチングで再利用しています。

これにより、パターンの解析やコンパイルコストを削減できます。

RegexOptions.Compiled

RegexOptions.Compiledを指定すると、正規表現パターンがILコードにコンパイルされ、実行時のマッチングが高速化されます。

特に大量のマッチングを繰り返す場合に効果的です。

using System;
using System.Text.RegularExpressions;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"\d+";
        var stopwatch = new Stopwatch();
        // 非コンパイル版
        stopwatch.Start();
        for (int i = 0; i < 100000; i++)
        {
            Regex.IsMatch(input, pattern);
        }
        stopwatch.Stop();
        Console.WriteLine($"非コンパイル: {stopwatch.ElapsedMilliseconds} ms");
        // コンパイル版
        var regexCompiled = new Regex(pattern, RegexOptions.Compiled);
        stopwatch.Restart();
        for (int i = 0; i < 100000; i++)
        {
            regexCompiled.IsMatch(input);
        }
        stopwatch.Stop();
        Console.WriteLine($"コンパイル: {stopwatch.ElapsedMilliseconds} ms");
    }
}

Compiledオプションは初回のコンパイルに時間がかかるため、使い回すインスタンスで利用するのが望ましいです。

頻繁に異なるパターンを使う場合は逆に遅くなることもあります。

ソースジェネレーター活用

.NET 5以降では、正規表現のパフォーマンスをさらに向上させるために、Regexソースジェネレーターが導入されています。

これはコンパイル時に正規表現のコードを自動生成し、実行時のオーバーヘッドを大幅に削減します。

using System;
using System.Text.RegularExpressions;
[GeneratedRegex(@"^\d{3}-\d{4}$")]
partial class PostalCodeRegex
{
}
class Program
{
    static void Main()
    {
        var regex = new PostalCodeRegex();
        string postalCode = "123-4567";
        bool isMatch = regex.IsMatch(postalCode);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、[GeneratedRegex]属性を使い、郵便番号のパターンをソースジェネレーターでコンパイル時に生成しています。

これにより、実行時のパターン解析やコンパイルが不要になり、高速なマッチングが可能です。

ソースジェネレーターを使うには、プロジェクトのターゲットフレームワークが.NET 5以降であることと、System.Text.RegularExpressionsの対応バージョンが必要です。

Span<char>での高速化

C# 7.2以降で導入されたSpan<T>は、メモリ効率が良く高速な文字列処理を可能にします。

Regex自体はSpan<char>を直接受け取るAPIは標準ではありませんが、Span<char>を使って前処理や部分文字列の抽出を行い、正規表現の対象を絞ることでパフォーマンスを向上させることができます。

例えば、大きな文字列の一部だけをSpan<char>で切り出し、正規表現の対象を限定する方法です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Header: value\nContent: 12345\nFooter: end";
        ReadOnlySpan<char> span = input.AsSpan();
        // Content行だけを抽出してマッチング
        int start = input.IndexOf("Content:");
        if (start >= 0)
        {
            ReadOnlySpan<char> contentSpan = span.Slice(start, input.Length - start);
            string contentStr = contentSpan.ToString();
            string pattern = @"\d+";
            bool isMatch = Regex.IsMatch(contentStr, pattern);
            Console.WriteLine(isMatch); // 結果: True
        }
    }
}

このように、Span<char>で対象範囲を絞ることで、正規表現の処理対象を小さくし、無駄なマッチングを減らせます。

ベンチマーク計測手法

正規表現のパフォーマンスを正確に測定するには、単純なStopwatchによる計測だけでなく、より詳細なベンチマークツールを使うのが望ましいです。

Stopwatchによる簡易計測

using System;
using System.Diagnostics;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"\d+";
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < 100000; i++)
        {
            Regex.IsMatch(input, pattern);
        }
        stopwatch.Stop();
        Console.WriteLine($"処理時間: {stopwatch.ElapsedMilliseconds} ms");
    }
}

BenchmarkDotNetの活用

より正確なベンチマークには、BenchmarkDotNetというライブラリが便利です。

JITの影響やGCの影響を考慮し、詳細なレポートを生成します。

using System.Text.RegularExpressions;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class RegexBenchmark
{
    private readonly string input = "abc123xyz";
    private readonly Regex regexCompiled = new Regex(@"\d+", RegexOptions.Compiled);
    private readonly string pattern = @"\d+";
    [Benchmark]
    public bool StaticIsMatch() => Regex.IsMatch(input, pattern);
    [Benchmark]
    public bool CompiledRegex() => regexCompiled.IsMatch(input);
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<RegexBenchmark>();
    }
}

BenchmarkDotNetを使うと、複数の実装を比較し、どの方法が高速かを科学的に判断できます。

これらのパフォーマンス最適化手法を組み合わせて使うことで、正規表現の処理速度を大幅に改善できます。

特に大量のデータを扱う場合やリアルタイム処理が求められる場面で効果的です。

テストと検証

NUnitでのユニットテスト

正規表現を使ったコードは、想定通りにマッチングが行われるかどうかを確実に検証するためにユニットテストを書くことが重要です。

C#ではNUnitがよく使われるテストフレームワークの一つです。

以下は、Regex.IsMatchを使ったメールアドレス検証のユニットテスト例です。

using NUnit.Framework;
using System.Text.RegularExpressions;
namespace RegexTests
{
    public class EmailValidationTests
    {
        private const string Pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        [Test]
        public void ValidEmail_ShouldMatch()
        {
            string email = "user@example.com";
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.IsTrue(result, "有効なメールアドレスがマッチしませんでした。");
        }
        [Test]
        public void InvalidEmail_ShouldNotMatch()
        {
            string email = "user@@example..com";
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.IsFalse(result, "無効なメールアドレスがマッチしてしまいました。");
        }
    }
}

この例では、[Test]属性を付けたメソッドで正規表現のマッチ結果を検証しています。

Assert.IsTrueやAssert.IsFalseで期待値と実際の結果を比較し、テストの成否を判定します。

パラメータ化テスト

同じテストロジックを複数の入力値で繰り返し実行したい場合、NUnitのパラメータ化テストが便利です。

[TestCase]属性を使うことで、複数のテストケースを簡潔に記述できます。

using NUnit.Framework;
using System.Text.RegularExpressions;
namespace RegexTests
{
    public class EmailValidationTests
    {
        private const string Pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        [TestCase("user@example.com", true)]
        [TestCase("user.name+tag@example.co.jp", true)]
        [TestCase("user@@example.com", false)]
        [TestCase("user@example", false)]
        public void EmailValidation_TestCases(string email, bool expected)
        {
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.AreEqual(expected, result, $"メールアドレス '{email}' の検証結果が期待値と異なります。");
        }
    }
}

この例では、複数のメールアドレスと期待されるマッチ結果を[TestCase]で指定し、1つのテストメソッドでまとめて検証しています。

テストの追加や修正が容易になるため、保守性が向上します。

自動生成テストデータ

大量のテストケースを用意したい場合や、ランダムな文字列で正規表現の堅牢性を検証したい場合は、自動生成テストデータを活用します。

NUnitでは[TestCaseSource]属性を使い、外部メソッドやプロパティからテストデータを供給できます。

using NUnit.Framework;
using System.Collections.Generic;
using System.Text.RegularExpressions;
namespace RegexTests
{
    public class EmailValidationTests
    {
        private const string Pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        public static IEnumerable<TestCaseData> EmailTestData()
        {
            yield return new TestCaseData("valid@example.com", true);
            yield return new TestCaseData("invalid@@example.com", false);
            yield return new TestCaseData("user.name+tag@example.co.jp", true);
            yield return new TestCaseData("user@.com", false);
            // ランダム生成例(簡易)
            for (int i = 0; i < 5; i++)
            {
                string randomEmail = GenerateRandomEmail();
                yield return new TestCaseData(randomEmail, false);
            }
        }
        private static string GenerateRandomEmail()
        {
            // 簡易的にランダム文字列を生成(実際はより複雑に生成可能)
            var chars = "abcdefghijklmnopqrstuvwxyz0123456789";
            var random = new System.Random();
            char[] buffer = new char[10];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = chars[random.Next(chars.Length)];
            }
            return new string(buffer) + "@example.com";
        }
        [Test, TestCaseSource(nameof(EmailTestData))]
        public void EmailValidation_WithGeneratedData(string email, bool expected)
        {
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.AreEqual(expected, result, $"メールアドレス '{email}' の検証結果が期待値と異なります。");
        }
    }
}

この例では、EmailTestDataメソッドでテストケースを列挙し、静的なケースと簡易的に生成したランダムなメールアドレスを混在させています。

[TestCaseSource]でデータを供給し、テストメソッドで検証しています。

自動生成テストデータを使うことで、未知のパターンや境界値を含む多様なケースを効率的に検証でき、正規表現の信頼性を高められます。

デバッグとチューニング

Visual StudioのRegexツール

Visual Studioには正規表現の作成やテストに便利なツールが組み込まれています。

特に「検索と置換」機能の正規表現モードや、拡張機能として提供されている正規表現エディタを活用すると、パターンの動作確認やデバッグが効率的に行えます。

検索と置換の正規表現モード

Visual Studioの「検索」ダイアログで「正規表現を使用する」オプションを有効にすると、正規表現を使った検索が可能です。

ここでパターンを入力し、対象のテキストに対してマッチするかを即座に確認できます。

ただし、Visual Studioの正規表現エンジンは.NETの正規表現とは一部仕様が異なるため、複雑なパターンは注意が必要です。

正規表現エディタ拡張

Visual Studio Marketplaceには、正規表現の作成・テストを支援する拡張機能が多数あります。

例えば「Regex Editor」や「Regex Tester」などは、リアルタイムでマッチ結果を表示し、グループのキャプチャ内容も確認できるため、複雑なパターンのデバッグに役立ちます。

これらのツールを使うことで、Visual Studio内でコードを書きながら正規表現の動作を確認でき、開発効率が向上します。

コンソールでのマッチ確認

簡単な正規表現の動作確認は、コンソールアプリケーションを作成して実行する方法も有効です。

実際のコードに近い環境でテストできるため、パターンの動作やマッチ結果を詳細に把握できます。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "user@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine($"入力: {input}");
        Console.WriteLine($"パターン: {pattern}");
        Console.WriteLine($"マッチ結果: {isMatch}");
        if (isMatch)
        {
            Match match = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            Console.WriteLine($"マッチした部分: {match.Value}");
        }
    }
}

入力: user@example.com
パターン: ^[\w\.-]+@[\w\.-]+\.\w+$
マッチ結果: True
マッチした部分: user@example.com

このように、コンソールで実行するとマッチの有無だけでなく、マッチした文字列やグループの内容も確認でき、デバッグに役立ちます。

コメント付き正規表現で可読性向上

複雑な正規表現は一行で書くと非常に読みにくく、保守性が低下します。

RegexOptions.IgnorePatternWhitespaceオプションを使うと、パターン内に空白や改行、コメントを入れて可読性を高められます。

コメント付き正規表現の例を示します。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "user.name@example.com";
        string pattern = @"
            ^                   # 文字列の先頭
            [\w\.-]+            # ユーザー名(英数字、ドット、ハイフン)
            @                   # @記号
            [\w\.-]+            # ドメイン名
            \.                  # ドット
            \w+                 # トップレベルドメイン
            $                   # 文字列の末尾
        ";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
        Console.WriteLine(isMatch); // 結果: True
    }
}

この例では、パターンを複数行に分けてコメントを入れているため、何を表しているかが一目でわかります。

IgnorePatternWhitespaceを指定することで、空白や改行は無視され、コメントは#以降の行末まで無視されます。

コメント付き正規表現は、チーム開発や長期保守の際に特に有効で、パターンの意味を明確に伝えられます。

これらのデバッグ・チューニング手法を活用することで、正規表現の開発効率と品質を大幅に向上させられます。

Visual Studioのツールやコンソールでの確認、コメント付き正規表現の活用を積極的に取り入れてください。

外部ツールと支援サービス

Regex101の活用

Regex101は、Webブラウザ上で正規表現の作成・テストができる非常に便利なオンラインツールです。

C#の正規表現(.NET)にも対応しており、リアルタイムでマッチ結果やキャプチャグループの内容を確認できます。

主な特徴は以下の通りです。

リアルタイムマッチング

入力したテキストに対して、正規表現がどのようにマッチするか即座に確認できます。

マッチした部分は色分けされ、視覚的にわかりやすいです。

詳細な説明表示

正規表現の各部分にカーソルを合わせると、その意味や動作の説明が表示されます。

正規表現の理解を深めるのに役立ちます。

デバッグ機能

マッチングのステップを追うことができ、どのようにパターンが評価されているかを詳細に確認可能です。

共有機能

作成した正規表現とテストデータをURLで共有でき、チーム内でのレビューや相談に便利です。

フラグ設定

大文字・小文字無視やマルチラインモードなど、正規表現のオプションを簡単に切り替えられます。

C#の正規表現を設計・検証する際は、まずRegex101で動作を確認し、問題がなければコードに組み込む流れが効率的です。

dotnet regex analyzer

dotnet regex analyzerは、.NET環境で正規表現の解析や最適化を支援するツールです。

Visual Studioの拡張機能やコマンドラインツールとして提供されており、正規表現のパフォーマンス問題や潜在的なエラーを検出します。

主な機能は以下の通りです。

パターンの静的解析

正規表現の構文エラーや非推奨の構文、パフォーマンスに悪影響を与えるパターンを検出します。

バックトラッキングの警告

バックトラッキングが多発しやすいパターンを指摘し、タイムアウトやパフォーマンス低下のリスクを教えてくれます。

最適化提案

より効率的なパターンへの書き換え案を提示し、パフォーマンス改善をサポートします。

Visual Studio統合

コード内の正規表現リテラルに対してリアルタイムで解析結果を表示し、開発中に問題を早期発見できます。

このツールを活用することで、正規表現の品質向上とパフォーマンス最適化が容易になり、トラブルを未然に防げます。

VS拡張機能

Visual Studioには、正規表現の作成・テスト・解析を支援する拡張機能が多数存在します。

代表的なものをいくつか紹介します。

Regex Editor

正規表現のリアルタイムテストができるエディタ機能を提供します。

入力したパターンに対してマッチ結果やキャプチャグループを即座に確認可能です。

Regex Toolkit

複雑な正規表現の可視化やデバッグを支援し、パターンの構造をツリー表示で理解しやすくします。

ReSharper

JetBrainsのReSharperは、正規表現の構文チェックやリファクタリング支援機能を備えています。

コード品質向上に役立ちます。

Regex Previewer

コード内の正規表現リテラルに対して、マッチ結果のプレビューを表示し、編集時の即時フィードバックを提供します。

これらの拡張機能を導入することで、Visual Studio上で効率的に正規表現の開発・デバッグが行えます。

特に複雑なパターンを扱う場合やチーム開発では、ツールの活用が生産性向上に直結します。

代替アプローチ

string.ContainsやStartsWith

正規表現は強力ですが、単純な文字列の部分一致や先頭一致を判定するだけなら、string.Containsやstring.StartsWithを使うほうがシンプルで高速です。

これらは正規表現のオーバーヘッドがなく、処理が軽いためパフォーマンス面で有利です。

例：文字列に特定の部分文字列が含まれるか判定

using System;
class Program
{
    static void Main()
    {
        string input = "example.txt";
        bool containsTxt = input.Contains(".txt", StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(containsTxt); // 結果: True
    }
}

この例では、.txtが含まれているかどうかを大文字・小文字を区別せずに判定しています。

例：文字列が特定の文字列で始まるか判定

using System;
class Program
{
    static void Main()
    {
        string input = "HelloWorld";
        bool startsWithHello = input.StartsWith("hello", StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(startsWithHello); // 結果: True
    }
}

StartsWithは文字列の先頭一致を判定し、StringComparisonを指定することで大文字・小文字の区別を制御できます。

これらのメソッドは単純なパターン判定に最適で、正規表現を使うよりもコードが読みやすくなります。

SpanHelpersによる高速判定

Span<char>を活用したSpanHelpersは、文字列の部分一致や検索を高速に行うための内部API群です。

直接利用は推奨されませんが、ReadOnlySpan<char>を使った文字列操作はパフォーマンス向上に効果的です。

例えば、ReadOnlySpan<char>のStartsWithやContainsメソッドを使うと、ヒープ割り当てを抑えつつ高速に判定できます。

using System;
class Program
{
    static void Main()
    {
        ReadOnlySpan<char> input = "example.txt".AsSpan();
        bool containsTxt = input.Slice(input.Length - 4).SequenceEqual(".txt".AsSpan());
        Console.WriteLine(containsTxt); // 結果: True
        bool startsWithEx = input.StartsWith("ex".AsSpan(), StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(startsWithEx); // 結果: True
    }
}

この例では、AsSpanで文字列をReadOnlySpan<char>に変換し、部分文字列の比較を行っています。

SequenceEqualやStartsWithは割り当てなしで高速に動作します。

SpanHelpersは.NET内部で使われる低レベルAPIですが、ReadOnlySpan<char>を活用することで同様の高速判定が可能です。

大量の文字列処理やリアルタイム処理で効果を発揮します。

C#パターンマッチングとの比較

C# 7.0以降で導入されたパターンマッチングは、型や値の判定を簡潔に書ける機能です。

正規表現の代わりに使うことは少ないですが、特定の条件判定や文字列の簡単なパターンチェックには有効です。

例：文字列の先頭が特定の文字列か判定

using System;
class Program
{
    static void Main()
    {
        string input = "HelloWorld";
        bool startsWithHello = input switch
        {
            string s when s.StartsWith("Hello", StringComparison.OrdinalIgnoreCase) => true,
            _ => false
        };
        Console.WriteLine(startsWithHello); // 結果: True
    }
}

パターンマッチングは条件分岐を簡潔に書けるため、複雑なif-elseを減らせます。

例：文字列の形式に応じた処理分岐

using System;
class Program
{
    static void Main()
    {
        string input = "123-4567";
        string result = input switch
        {
            string s when System.Text.RegularExpressions.Regex.IsMatch(s, @"^\d{3}-\d{4}$") => "郵便番号形式",
            string s when s.StartsWith("http") => "URL形式",
            _ => "不明な形式"
        };
        Console.WriteLine(result); // 結果: 郵便番号形式
    }
}

このように、パターンマッチングは正規表現と組み合わせて使うことも多く、条件分岐の可読性を高めます。

正規表現は強力ですが、単純な文字列判定や高速処理が求められる場合は、stringのメソッドやSpan<char>、C#のパターンマッチングを活用することで、より効率的で読みやすいコードが書けます。

用途に応じて使い分けることが重要です。

保守性を高める設計

パターンの定数化

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

保守性を高めるためには、パターンを定数として一元管理することが重要です。

using System;
using System.Text.RegularExpressions;
class Program
{
    private const string EmailPattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
    static void Main()
    {
        string email = "user@example.com";
        bool isMatch = Regex.IsMatch(email, EmailPattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

このように定数化することで、パターンの変更が必要になった際に定数の値を修正するだけで済み、コード全体の整合性を保ちやすくなります。

また、複数のパターンをまとめて管理するクラスやファイルを作成し、用途別に分類するとさらに保守性が向上します。

ラッパーメソッド

正規表現の呼び出しを直接コードに書くのではなく、ラッパーメソッドを作成して抽象化する方法も保守性向上に効果的です。

これにより、パターンの変更やオプションの追加を一箇所で管理でき、呼び出し側のコードはシンプルになります。

using System;
using System.Text.RegularExpressions;
class Validator
{
    private const string EmailPattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
    public static bool IsValidEmail(string input)
    {
        return Regex.IsMatch(input, EmailPattern, RegexOptions.IgnoreCase);
    }
}
class Program
{
    static void Main()
    {
        string email = "user@example.com";
        bool isValid = Validator.IsValidEmail(email);
        Console.WriteLine(isValid); // 結果: True
    }
}