【C#】ContainsとCompareInfoで柔軟に実装する文字列の部分一致比較テクニック

2025-05-15更新日: 2025-05-15

C#で部分一致を調べるならString.Containsが第1候補です。

大文字小文字を無視したい場合はStringComparison.OrdinalIgnoreCaseを指定し、全角半角やひらがなカタカナも統一したい場合はCompareInfo.IndexOfとCompareOptionsを組み合わせると柔軟に対応できます。

目次から探す

部分一致に使う主要メソッド
- String.Contains
- CompareInfo.IndexOf
CompareOptionsで広がる柔軟性
Unicode正規化を前提にした比較
実装パターン別サンプル
性能検証とチューニング
セキュリティと国際化の注意点
代替アプローチの比較
よくあるエラーとデバッグ術
まとめ

部分一致に使う主要メソッド

文字列の部分一致を実装する際に、C#では主にString.ContainsメソッドとCompareInfo.IndexOfメソッドが使われます。

ここではそれぞれの特徴や使い方を詳しく解説します。

String.Contains

シグネチャと戻り値

String.Containsは、指定した部分文字列が対象の文字列に含まれているかどうかを判定するメソッドです。

基本的なシグネチャは以下の通りです。

public bool Contains(string value);
public bool Contains(string value, StringComparison comparisonType);

value：検索したい部分文字列を指定します
comparisonType(オプション)：比較方法を指定するStringComparison列挙体です。これを指定しない場合は大文字小文字を区別するカルチャ非依存の比較Ordinalが行われます

戻り値はbool型で、部分文字列が含まれていればtrue、含まれていなければfalseを返します。

Ordinal比較とカルチャ比較の違い

Containsメソッドは、StringComparisonを指定しない場合、デフォルトでOrdinal比較を行います。

これは文字コードのバイナリ比較であり、文化や言語の違いを考慮しません。

一方、StringComparisonでCurrentCultureやInvariantCultureを指定すると、カルチャに基づいた比較が行われます。

これにより、言語特有の大文字小文字の違いや特殊文字の扱いが反映されます。

例えば、トルコ語の「i」と「İ」の違いなど、カルチャ依存の比較が必要な場合はCurrentCultureIgnoreCaseなどを使うと良いでしょう。

大文字小文字の扱い

Containsメソッドは、StringComparisonを指定しない場合は大文字小文字を区別します。

大文字小文字を無視して部分一致を判定したい場合は、StringComparison.OrdinalIgnoreCaseやStringComparison.CurrentCultureIgnoreCaseを指定します。

以下は大文字小文字を無視した部分一致の例です。

string mainString = "Hello World";
string subString = "world";
bool contains = mainString.Contains(subString, StringComparison.OrdinalIgnoreCase);
Console.WriteLine(contains); // 出力: True

このように、StringComparisonを活用することで柔軟な比較が可能です。

パフォーマンス特性

String.Containsは内部的にIndexOfを使って部分文字列の位置を検索しています。

Ordinal比較はバイナリ比較のため高速ですが、CurrentCultureなどのカルチャ依存比較はやや遅くなります。

また、Containsは文字列の長さや検索対象の文字列の長さに比例して処理時間が増加します。

非常に大きな文字列や大量の検索を行う場合はパフォーマンスに注意が必要です。

典型的な落とし穴

nullや空文字列を渡すと例外が発生するため、事前にチェックが必要です
大文字小文字を区別しない比較をしたい場合にStringComparisonを指定し忘れることが多いです
全角半角やひらがなカタカナの違いはContainsでは無視できません。これらを考慮したい場合はCompareInfoを使う必要があります

CompareInfo.IndexOf

メソッド概要

CompareInfoクラスは、カルチャに依存した文字列比較を行うための機能を提供します。

IndexOfメソッドは、指定した部分文字列が対象文字列のどの位置に現れるかを返します。

シグネチャは以下の通りです。

public int IndexOf(string source, string value, CompareOptions options);

source：検索対象の文字列
value：検索したい部分文字列
options：比較オプションを指定するCompareOptions列挙体

CompareOptionsを使うことで、大文字小文字の無視、全角半角の無視、ひらがなカタカナの無視など、より柔軟な比較が可能です。

返却値の解釈

IndexOfは部分文字列が見つかった場合、その開始位置(0から始まるインデックス)を返します。

見つからなかった場合は-1を返します。

このため、部分一致の判定は以下のように行います。

bool contains = compareInfo.IndexOf(source, value, options) >= 0;

実行コストの目安

CompareInfo.IndexOfはカルチャ依存の比較を行うため、String.ContainsのOrdinal比較よりは処理コストが高くなります。

特にIgnoreWidth(全角半角無視)やIgnoreKanaType(ひらがなカタカナ無視)などのオプションを指定すると、内部で複雑な正規化処理が行われるため、パフォーマンスに影響します。

ただし、これらのオプションを使うことでユーザーの期待に沿った柔軟な検索が可能になるため、用途に応じて使い分けることが重要です。

以下はCompareInfo.IndexOfを使った部分一致の例です。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string mainString = "ABCDE";
        string subString = "ABCDE";
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        bool contains = compareInfo.IndexOf(mainString, subString, CompareOptions.IgnoreWidth) >= 0;
        Console.WriteLine(contains); // 出力: True
    }
}

この例では、全角と半角の違いを無視して部分一致を判定しています。

以上のように、String.Containsはシンプルで高速な部分一致判定に適しており、CompareInfo.IndexOfはより柔軟でカルチャ依存の比較が必要な場合に活用します。

用途に応じて使い分けることで、文字列検索の精度とパフォーマンスを両立できます。

CompareOptionsで広がる柔軟性

CompareOptionsは、CompareInfoクラスの文字列比較メソッドで使われる列挙体で、比較の挙動を細かく制御できます。

これにより、単純な部分一致だけでなく、文化的な違いや文字の表記ゆれを考慮した柔軟な比較が可能です。

IgnoreCase

IgnoreCaseは大文字小文字の違いを無視して比較を行います。

これにより、”Apple”と”apple”、”HELLO”と”hello”のような文字列が同一視されます。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string source = "Hello World";
        string target = "hello";
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        bool contains = compareInfo.IndexOf(source, target, CompareOptions.IgnoreCase) >= 0;
        Console.WriteLine(contains); // 出力: True
    }
}

True

この例では、大文字小文字の違いを無視して部分一致を判定しています。

IgnoreCaseは多くのシナリオで基本的に使われるオプションです。

IgnoreWidth

IgnoreWidthは全角と半角の違いを無視して比較します。

日本語や中国語などの東アジア圏で特に有効です。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string source = "ＡＢＣＤＥ";  // 全角
        string target = "ABCDE";      // 半角
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        bool contains = compareInfo.IndexOf(source, target, CompareOptions.IgnoreWidth) >= 0;
        Console.WriteLine(contains); // 出力: True
    }
}

True

全角と半角の違いを無視することで、ユーザー入力の表記ゆれを吸収しやすくなります。

IgnoreKanaType

IgnoreKanaTypeはひらがなとカタカナの違いを無視して比較します。

日本語の検索機能でよく使われるオプションです。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string source = "あいうえお";  // ひらがな
        string target = "アイウエオ";  // カタカナ
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        bool contains = compareInfo.IndexOf(source, target, CompareOptions.IgnoreKanaType) >= 0;
        Console.WriteLine(contains); // 出力: True
    }
}

True

ひらがなとカタカナの違いを無視することで、より自然な日本語の部分一致検索が実現できます。

IgnoreSymbols

IgnoreSymbolsは空白や記号を無視して比較します。

文章中のスペースや句読点の違いを吸収したい場合に便利です。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string source = "あ い、う。え お";  // 空白と記号あり
        string target = "あいうえお";        // 空白・記号なし
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        bool contains = compareInfo.IndexOf(source, target, CompareOptions.IgnoreSymbols) >= 0;
        Console.WriteLine(contains); // 出力: True
    }
}

True

このオプションを使うと、ユーザーの入力ミスや表記ゆれに強い検索が可能になります。

StringSort

StringSortは文字列のソート順を制御するオプションで、比較の際に文字の並び順を文字コード順に近づける効果があります。

部分一致の判定にはあまり使われませんが、ソート処理と組み合わせる場合に役立ちます。

// StringSortは主にソート時に使われるため、部分一致の例は省略します。

オプションの組み合わせと優先順位

CompareOptionsは複数のオプションをビット演算子|で組み合わせて使えます。

例えば、大文字小文字を無視しつつ全角半角も無視したい場合は以下のように指定します。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string source = "Apple";
        string target = "apple";
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        CompareOptions options = CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth;
        bool contains = compareInfo.IndexOf(source, target, options) >= 0;
        Console.WriteLine(contains); // 出力: True
    }
}

True

複数オプションを組み合わせる際のポイントは以下の通りです。

オプション名	効果	備考
IgnoreCase	大文字小文字を無視	多くの検索で基本的に使う
IgnoreWidth	全角半角の違いを無視	東アジア圏の表記ゆれに有効
IgnoreKanaType	ひらがなカタカナの違いを無視	日本語特有の表記ゆれに対応
IgnoreSymbols	空白や記号を無視	ユーザー入力の誤差を吸収
StringSort	ソート順の調整	部分一致よりソートで使うことが多い

オプションの優先順位は明確にドキュメント化されていませんが、IndexOfは指定されたすべてのオプションを考慮して比較を行います。

複数のオプションを組み合わせることで、より柔軟でユーザーフレンドリーな部分一致検索が実現できます。

Unicode正規化を前提にした比較

Unicode文字列の比較では、同じ見た目の文字でも内部的なコードポイントの違いにより一致しないケースがあります。

これを防ぐためにUnicode正規化(Normalization)を行い、文字列を統一した形に変換してから比較することが重要です。

NFCとNFDの違い

Unicode正規化には主にNFC(Normalization Form C)とNFD(Normalization Form D)の2種類があります。

NFC(正規化形式C)

合成済みの文字を使う形式です。

例えば、「é」は単一の合成文字(U+00E9)として表現されます。

NFD(正規化形式D)

分解済みの文字を使う形式です。

例えば、「é」は「e」(U+0065)と「´」(U+0301、結合アクセント)に分解されて表現されます。

この違いにより、同じ文字列でもNFCとNFDで表現が異なるため、直接比較すると不一致になることがあります。

using System;
using System.Text;
class Program
{
    static void Main()
    {
        string nfc = "é";  // U+00E9
        string nfd = "e\u0301";  // 'e' + 結合アクセント
        Console.WriteLine(nfc == nfd);  // 出力: False
        string normalizedNfc = nfc.Normalize(NormalizationForm.FormC);
        string normalizedNfd = nfd.Normalize(NormalizationForm.FormC);
        Console.WriteLine(normalizedNfc == normalizedNfd);  // 出力: True
    }
}

False
True

この例では、正規化を行うことで同じ文字列として扱えるようになります。

事前Normalizeの効果

文字列を比較する前に正規化を行うことで、Unicodeの表現の違いによる不一致を防げます。

特に日本語やアクセント付き文字を含む多言語環境では必須の処理です。

正規化はstring.Normalizeメソッドで行い、通常はNFC(FormC)を使うことが多いです。

これにより、合成済み文字で統一され、比較処理が安定します。

using System;
using System.Text;

class Program
{
    static void Main()
    {
        // 分解形：「e」＋結合アキュート(U+0301)
        string source = "cafe\u0301";

        // 合成形：U+00E9『é』を使う
        string target = "café";

        // 正規化前の包含判定（false が期待値）
        bool containsBefore = source.Contains(target);

        // 正規化後は双方を NFC にそろえて判定（true が期待値）
        bool containsAfter = source
            .Normalize(NormalizationForm.FormC)
            .Contains(target.Normalize(NormalizationForm.FormC));

        // 要件：ブール値のみを 2 行出力
        Console.WriteLine(containsBefore);
        Console.WriteLine(containsAfter);
    }
}

正規化前: False
正規化後: True

このように、正規化を事前に行うことで、見た目は同じでも内部的に異なる文字列の部分一致を正しく判定できます。

濁点・半濁点の扱い

日本語の濁点(゛)や半濁点(゜)は、単独の結合文字として表現されることがあります。

例えば、「が」は「か」＋濁点の結合文字であり、「が」とは異なるコードポイントの組み合わせです。

正規化を行うことで、これらの結合文字を合成済みの単一文字に変換でき、比較が容易になります。

using System;
using System.Text;
class Program
{
    static void Main()
    {
        string combined = "が";          // 単一文字 U+304C
        string decomposed = "か\u3099";  // 「か」+ 濁点 U+3099
        Console.WriteLine(combined == decomposed);  // 出力: False
        string normalizedCombined = combined.Normalize(NormalizationForm.FormC);
        string normalizedDecomposed = decomposed.Normalize(NormalizationForm.FormC);
        Console.WriteLine(normalizedCombined == normalizedDecomposed);  // 出力: True
    }
}

False
True

濁点や半濁点を含む文字列の比較でも、正規化を行うことで正確な部分一致が可能になります。

Unicode正規化は日本語の文字列処理において特に重要なポイントです。

実装パターン別サンプル

ログ検索での部分一致

ログ検索では、膨大なテキストの中から特定のキーワードを含む行を効率的に抽出することが求められます。

部分一致検索はユーザーが入力したキーワードがログのどこかに含まれているかを判定するために使われます。

以下は、String.Containsを使ったシンプルなログ検索の例です。

大文字小文字を無視して検索しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var logs = new List<string>
        {
            "2024-06-01 10:00:00 Error: ファイルが見つかりません",
            "2024-06-01 10:05:00 Info: 処理が正常に完了しました",
            "2024-06-01 10:10:00 Warning: メモリ使用率が高いです",
            "2024-06-01 10:15:00 Error: ネットワーク接続が切断されました"
        };
        string keyword = "error";
        foreach (var log in logs)
        {
            // 大文字小文字を無視して部分一致検索
            if (log.Contains(keyword, StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine(log);
            }
        }
    }
}

2024-06-01 10:00:00 Error: ファイルが見つかりません
2024-06-01 10:15:00 Error: ネットワーク接続が切断されました

この例では、StringComparison.OrdinalIgnoreCaseを指定しているため、「Error」や「error」など大文字小文字の違いを無視して検索できます。

ログの内容が多言語や特殊文字を含む場合は、CompareInfo.IndexOfとCompareOptionsを使ってさらに柔軟に対応可能です。

入力補完でのリアルタイムフィルタ

ユーザーが入力する文字列に応じて候補をリアルタイムに絞り込む入力補完機能では、部分一致検索が頻繁に行われます。

パフォーマンスが重要なため、効率的な比較方法を選ぶ必要があります。

以下は、CompareInfo.IndexOfを使い、大文字小文字を無視しつつ全角半角の違いも吸収する例です。

using System;
using System.Collections.Generic;
using System.Globalization;
class Program
{
    static void Main()
    {
        var items = new List<string>
        {
            "アップル",
            "バナナ",
            "みかん",
            "グレープ",
            "パイナップル"
        };
        string input = "ﾊﾟｲﾅｯﾌﾟﾙ";  // 半角カタカナ入力
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        var options = CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth | CompareOptions.IgnoreKanaType;
        foreach (var item in items)
        {
            if (compareInfo.IndexOf(item, input, options) >= 0)
            {
                Console.WriteLine(item);
            }
        }
    }
}

パイナップル

この例では、ユーザーが半角カタカナで入力しても、全角カタカナの候補が正しくマッチします。

IgnoreWidthとIgnoreKanaTypeを組み合わせることで、表記ゆれを吸収し、快適な入力補完を実現しています。

フルテキスト検索への応用

フルテキスト検索システムでは、単純な部分一致だけでなく、複雑な検索条件や多言語対応が求められます。

CompareInfoのオプションを活用しつつ、正規化やトークン化を組み合わせることで精度の高い検索が可能です。

以下は、簡易的に複数キーワードを部分一致で検索する例です。

大文字小文字を無視し、全角半角も無視しています。

using System;
using System.Collections.Generic;
using System.Globalization;
class Program
{
    static void Main()
    {
        var documents = new List<string>
        {
            "C#の文字列比較についての解説",
            "部分一致検索の実装方法",
            "全角半角の違いを無視した検索",
            "ひらがなカタカナの区別をなくす方法"
        };
        var keywords = new List<string> { "部分", "検索" };
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        var options = CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth | CompareOptions.IgnoreKanaType;
        foreach (var doc in documents)
        {
            bool allMatch = true;
            foreach (var keyword in keywords)
            {
                if (compareInfo.IndexOf(doc, keyword, options) < 0)
                {
                    allMatch = false;
                    break;
                }
            }
            if (allMatch)
            {
                Console.WriteLine(doc);
            }
        }
    }
}

部分一致検索の実装方法

この例では、複数のキーワードすべてが含まれる文書だけを抽出しています。

CompareOptionsを適切に設定することで、多様な表記ゆれに対応したフルテキスト検索の基礎が作れます。

大規模データセットとParallel処理

大量の文字列データに対して部分一致検索を行う場合、単純なループ処理では時間がかかることがあります。

Parallelクラスを使って並列処理を行うことで、CPUコアを有効活用し高速化が可能です。

以下は、Parallel.ForEachを使った部分一致検索の例です。

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        var largeDataset = new List<string>();
        for (int i = 0; i < 1000000; i++)
        {
            largeDataset.Add($"データ行{i}");
        }
        largeDataset.Add("特別なキーワードを含む行");
        string keyword = "キーワード";
        var compareInfo = CultureInfo.CurrentCulture.CompareInfo;
        var options = CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth;
        var results = new ConcurrentBag<string>();
        Parallel.ForEach(largeDataset, item =>
        {
            if (compareInfo.IndexOf(item, keyword, options) >= 0)
            {
                results.Add(item);
            }
        });
        foreach (var result in results)
        {
            Console.WriteLine(result);
        }
    }
}

特別なキーワードを含む行

この例では、100万件のデータからキーワードを含む行を並列で検索しています。

ConcurrentBagを使ってスレッドセーフに結果を収集し、効率的に処理しています。

大規模データの部分一致検索でパフォーマンスを向上させたい場合に有効な手法です。

性能検証とチューニング

文字列長と検索回数のベンチマーク

文字列の部分一致検索において、検索対象の文字列長や検索回数はパフォーマンスに大きく影響します。

長い文字列や大量の検索を行う場合、処理時間が増加するため、ベンチマークで実際の性能を測定することが重要です。

以下は、String.Containsを使って異なる長さの文字列に対して部分一致検索を繰り返す簡単なベンチマーク例です。

using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string longString = new string('a', 100000) + "target";
        string shortString = "target";
        string searchTerm = "target";
        int iterations = 10000;
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            bool found = longString.Contains(searchTerm);
        }
        sw.Stop();
        Console.WriteLine($"長い文字列検索時間: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            bool found = shortString.Contains(searchTerm);
        }
        sw.Stop();
        Console.WriteLine($"短い文字列検索時間: {sw.ElapsedMilliseconds} ms");
    }
}

長い文字列検索時間: 120 ms
短い文字列検索時間: 5 ms

この結果から、文字列が長くなるほど検索にかかる時間が増えることがわかります。

検索回数が多い場合は特に影響が大きいため、検索対象の文字列長を考慮した設計やキャッシュの活用が効果的です。

Span<char>を使った高速Contains

Span<char>は、メモリのコピーを伴わずに文字列の一部を参照できる構造体で、パフォーマンス向上に役立ちます。

Span<char>を使うことで、不要な文字列生成を避けつつ高速な部分一致検索が可能です。

以下は、Span<char>を使った部分一致検索の例です。

using System;
class Program
{
    static bool ContainsSpan(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
    {
        return source.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
    }
    static void Main()
    {
        string text = "Hello, World!";
        string search = "WORLD";
        bool result = ContainsSpan(text.AsSpan(), search.AsSpan());
        Console.WriteLine(result); // 出力: True
    }
}

True

Span<char>を使うことで、文字列の部分一致検索を効率的に行えます。

特に大量の文字列処理やリアルタイム処理で効果的です。

UnsafeコードとSIMD命令の概観

より高速な文字列検索を求める場合、unsafeコードやSIMD(Single Instruction Multiple Data)命令を活用する方法があります。

これらは低レベルのメモリアクセスや並列処理を利用し、CPUの性能を最大限に引き出します。

Unsafeコード

ポインタ操作により、文字列のバイト列を直接操作して高速化します。

ただし、メモリ安全性が損なわれるため注意が必要です。

SIMD命令

CPUのSIMD命令を使い、一度に複数の文字を比較することで高速化します。

.NETではSystem.Numerics.VectorやSystem.Runtime.Intrinsics名前空間で利用可能です。

以下はSIMDを使った文字列比較のイメージコードです(実際の部分一致検索はより複雑です)。

// SIMDを使った高速比較は高度な実装が必要なため、ここでは概要のみ示します。
// 実際にはVector<byte>やVector<ushort>を使い、複数文字を同時に比較します。

これらの技術はパフォーマンスを大幅に向上させますが、実装の難易度が高く、メンテナンス性や安全性のトレードオフがあります。

用途に応じて検討してください。

メモリ割り当ての最小化

部分一致検索で頻繁に文字列を生成したりコピーしたりすると、GC(ガベージコレクション)の負荷が増え、パフォーマンス低下の原因になります。

メモリ割り当てを最小化することが重要です。

Span<char>やReadOnlySpan<char>の活用

文字列の部分参照をコピーせずに扱えるため、不要なメモリ割り当てを防げます。

文字列の正規化や変換を事前に行う

毎回正規化や大文字小文字変換を行うとメモリ割り当てが増えるため、可能な限り一度だけ行いキャッシュする方法が有効です。

StringComparisonやCompareOptionsの適切な利用

これらの組み込み機能は内部で効率的に処理されるため、自前で文字列操作を行うよりメモリ効率が良い場合があります。

以下は、Span<char>を使いメモリ割り当てを抑えた部分一致検索の例です。

using System;
class Program
{
    static bool ContainsNoAlloc(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
    {
        return source.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
    }
    static void Main()
    {
        string text = "Memory allocation minimization example";
        string search = "allocation";
        bool result = ContainsNoAlloc(text.AsSpan(), search.AsSpan());
        Console.WriteLine(result); // 出力: True
    }
}

True

このように、メモリ割り当てを抑える工夫をすることで、GC負荷を軽減し、安定した高速処理が可能になります。

セキュリティと国際化の注意点

想定外マッチによる誤検知

部分一致検索を実装する際、意図しない文字列がマッチしてしまう誤検知のリスクがあります。

特にセキュリティ関連のフィルタリングや不正検知システムでは、誤検知が業務に大きな影響を与えるため注意が必要です。

たとえば、単純にContainsやCompareInfo.IndexOfでキーワードを検索すると、キーワードの一部が他の単語に含まれているだけでマッチしてしまうことがあります。

これにより、無関係な文字列が誤って検知されるケースが発生します。

string text = "This is a test of the system.";
string keyword = "test";
bool contains = text.Contains(keyword);  // True
string falsePositive = "contest";
bool falseMatch = falsePositive.Contains(keyword);  // True(誤検知の例)

この例では、「contest」という単語にも「test」が含まれているため、誤ってマッチと判定されます。

こうした誤検知を防ぐには、単語境界を考慮した正規表現の利用や、前後の文字をチェックするロジックを追加することが有効です。

また、多言語環境では文字の正規化や表記ゆれにより、意図しないマッチが増える可能性があるため、正規化やカルチャ依存の比較オプションを適切に設定することも重要です。

ソーシャルエンジニアリング対策

文字列の部分一致検索は、フィッシングメールや悪意あるメッセージの検出にも使われますが、攻撃者は文字の置き換えや類似文字を使って検知を回避しようとします。

これを防ぐためには、国際化対応とセキュリティの両面から対策が必要です。

たとえば、ラテン文字の「a」をキリル文字の「а」(見た目は同じだが異なるコードポイント)に置き換える手法があります。

これにより、単純な部分一致検索では検知できなくなります。

こうした攻撃を防ぐには、以下の対策が考えられます。

Unicode正規化の徹底

文字列を正規化し、異なる表現を統一することで検知漏れを減らせます。

類似文字の正規化やホモグリフ検出

見た目が似ているが異なる文字(ホモグリフ)を検出・置換するライブラリやアルゴリズムを導入します。

ホワイトリスト・ブラックリストの運用

信頼できる送信元や文字列をホワイトリスト化し、疑わしい文字列を重点的に検査します。

多層的な検知システムの構築

部分一致検索だけでなく、機械学習やパターンマッチングを組み合わせて検知精度を高めます。

これらの対策を組み合わせることで、ソーシャルエンジニアリング攻撃に対する耐性を強化できます。

CultureFallbackの落とし穴

.NETのカルチャ依存の文字列比較では、指定したカルチャが利用できない場合にフォールバック(代替カルチャ)が自動的に適用されることがあります。

これを「CultureFallback」と呼びますが、意図しない比較結果を招くことがあるため注意が必要です。

たとえば、特定のカルチャでの比較を期待してCompareInfoを取得しても、実行環境にそのカルチャが存在しない場合、別のカルチャにフォールバックされます。

これにより、文字の大文字小文字の扱いや特殊文字の比較ルールが変わり、部分一致の結果が変わることがあります。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        // 存在しないカルチャを指定(例: "xx-XX")
        CultureInfo ci;
        try
        {
            ci = new CultureInfo("xx-XX");
        }
        catch (CultureNotFoundException)
        {
            ci = CultureInfo.InvariantCulture;
        }
        var compareInfo = ci.CompareInfo;
        string source = "straße";
        string target = "STRASSE";
        bool result = compareInfo.IndexOf(source, target, CompareOptions.IgnoreCase) >= 0;
        Console.WriteLine($"比較結果: {result}");
    }
}

比較結果: False

この例では、存在しないカルチャを指定したためInvariantCultureにフォールバックされ、ドイツ語の「ß」と「ss」が等価とみなされず部分一致しません。

このような落とし穴を避けるためには、以下のポイントを押さえましょう。

カルチャの存在を事前に確認する

CultureInfo.GetCulturesで利用可能なカルチャをチェックし、存在しないカルチャを指定しない。

フォールバック先のカルチャを明示的に指定する

期待する比較結果が得られるカルチャを明示的に使います。

カルチャ依存の比較が不要な場合はOrdinal比較を使う

文化的な違いを考慮しない単純なバイナリ比較で安定した結果を得ります。

テスト環境で多様なカルチャを検証する

実際の運用環境でのカルチャ設定に依存しないか確認します。

これらの対策を講じることで、国際化対応の文字列比較における予期せぬ挙動を防ぎ、セキュリティや機能の信頼性を高められます。

代替アプローチの比較

Regex.IsMatchとの使い分け

正規表現を使ったRegex.IsMatchは、部分一致検索において非常に強力なツールです。

単純な文字列の部分一致だけでなく、パターンマッチングや複雑な条件を指定できるため、柔軟な検索が可能です。

ただし、Regex.IsMatchは正規表現の解析や実行にコストがかかるため、単純な部分一致検索にはオーバーヘッドが大きくなりがちです。

パフォーマンスが重要な場面では、String.ContainsやCompareInfo.IndexOfのほうが高速に動作します。

以下のポイントで使い分けると良いでしょう。

利用シーン	推奨メソッド	理由
単純な部分一致検索	`String.Contains`または`CompareInfo.IndexOf`	高速でシンプルな実装が可能
大文字小文字やカルチャ依存の比較	`CompareInfo.IndexOf`	柔軟な比較オプションが利用できる
複雑なパターンマッチング(ワイルドカード、繰り返しなど)	`Regex.IsMatch`	正規表現の強力な表現力を活用できる
入力が動的で複雑なパターンを扱う場合	`Regex.IsMatch`	パターンの柔軟な変更に対応しやすい

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string text = "abc123xyz";
        string pattern = @"\d{3}";  // 3桁の数字を検索
        bool isMatch = Regex.IsMatch(text, pattern);
        Console.WriteLine(isMatch);  // 出力: True
    }
}

True

このように、正規表現はパターンが複雑な場合に有効ですが、単純な部分一致には過剰な場合が多いので使い分けが重要です。

StartsWith・EndsWithの限定的利用

StartsWithとEndsWithは文字列の先頭や末尾が特定の文字列で始まる・終わるかを判定するメソッドです。

部分一致検索の中でも限定的な用途に適しています。

StartsWith

文字列の先頭が指定文字列と一致するかを判定します。

URLのスキーム判定やファイル拡張子のチェックなどに使われます。

EndsWith

文字列の末尾が指定文字列と一致するかを判定します。

ファイル名の拡張子判定や特定の接尾辞の検出に便利です。

これらは部分文字列が文字列の途中にあるかどうかは判定できないため、部分一致検索の代替としては限定的です。

using System;
class Program
{
    static void Main()
    {
        string filename = "document.pdf";
        bool isPdf = filename.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(isPdf);  // 出力: True
    }
}

True

部分一致検索の中で、先頭や末尾の判定だけで十分な場合はStartsWithやEndsWithを使うと効率的です。

サードパーティ検索ライブラリ紹介

より高度な部分一致検索や全文検索を実現したい場合、サードパーティの検索ライブラリを利用する選択肢があります。

これらは高速なインデックス作成や多言語対応、複雑な検索クエリのサポートなど、多機能な検索機能を提供します。

代表的なライブラリには以下があります。

ライブラリ名	特徴	利用シーン
Lucene.NET	高速な全文検索エンジン。インデックス作成と検索が可能です。	大規模データの全文検索や複雑なクエリ処理に最適。
ElasticSearch	分散型全文検索エンジン。REST APIで操作可能です。	クラウド環境や分散システムでの大規模検索に適用。
Sphinx	高速な全文検索サーバー。MySQL連携も可能です。	データベース連携が必要な全文検索に利用されます。
FuzzySharp	あいまい検索(ファジーマッチング)に特化。	スペルミスや表記ゆれを許容した検索に便利。

これらのライブラリは、単純な部分一致検索よりも複雑な要件に対応できるため、検索機能の拡張や高性能化を目指す場合に検討すると良いでしょう。

ただし、導入には学習コストや運用コストがかかるため、要件に応じて適切に選択してください。

よくあるエラーとデバッグ術

Null参照と空文字列の扱い

部分一致検索を実装する際に最も多いエラーの一つが、null参照による例外です。

String.ContainsやCompareInfo.IndexOfにnullや空文字列を渡すと、ArgumentNullExceptionや予期しない動作が発生することがあります。

string source = null;
string target = "test";
bool contains = source.Contains(target);  // NullReferenceExceptionが発生

このようなエラーを防ぐためには、検索前にnullチェックを必ず行うことが重要です。

また、空文字列を検索する場合は、Containsは常にtrueを返す仕様なので、意図しない結果にならないように注意が必要です。

string source = "example";
string target = "";
bool contains = source.Contains(target);  // trueになる
// 意図しない場合は空文字列を除外する
if (!string.IsNullOrEmpty(target))
{
    contains = source.Contains(target);
}
else
{
    contains = false;  // または適切な処理
}

CompareInfo.IndexOfも同様にnullを渡すと例外が発生します。

安全に扱うために、引数の検証を徹底しましょう。

パフォーマンス低下の兆候

部分一致検索のパフォーマンスが低下している場合、以下のような兆候が見られます。

レスポンスの遅延

ユーザー操作に対して検索結果の表示が遅くなります。

CPU使用率の急増

検索処理中にCPU負荷が高くなります。

メモリ使用量の増加

ガベージコレクションが頻繁に発生し、メモリ消費が増えます。

これらの兆候は、検索対象の文字列が非常に長い、検索回数が多い、または不適切な比較オプションの使用によるものが多いです。

パフォーマンス低下を検出するには、Stopwatchで処理時間を計測したり、プロファイラでCPUやメモリの使用状況を監視することが有効です。

var sw = Stopwatch.StartNew();
// 検索処理
sw.Stop();
Console.WriteLine($"検索時間: {sw.ElapsedMilliseconds} ms");

また、CompareOptionsの過剰な組み合わせや、正規化処理の頻繁な実行もパフォーマンスに影響します。

必要なオプションだけを選択し、正規化は事前に済ませるなどの工夫が求められます。

推奨される例外処理

部分一致検索で発生しうる例外には、主に以下があります。

ArgumentNullException：null引数が渡された場合
ArgumentException：不正な引数やオプションが指定された場合
CultureNotFoundException：存在しないカルチャを指定した場合

これらの例外を適切にハンドリングすることで、アプリケーションの安定性を高められます。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        try
        {
            string source = "example";
            string target = null;
            if (string.IsNullOrEmpty(target))
                throw new ArgumentNullException(nameof(target), "検索文字列がnullまたは空です。");
            bool contains = source.Contains(target, StringComparison.OrdinalIgnoreCase);
            Console.WriteLine(contains);
        }
        catch (ArgumentNullException ex)
        {
            Console.WriteLine($"引数エラー: {ex.Message}");
        }
        catch (CultureNotFoundException ex)
        {
            Console.WriteLine($"カルチャエラー: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"予期しないエラー: {ex.Message}");
        }
    }
}

引数エラー: 検索文字列がnullまたは空です。 (Parameter 'target')

例外処理では、ユーザーにわかりやすいメッセージを表示し、ログに詳細を記録することが望ましいです。

また、例外が発生しうる箇所は事前に入力検証を行い、例外発生を未然に防ぐ設計が推奨されます。

まとめ

C#での文字列部分一致検索は、String.ContainsやCompareInfo.IndexOfを使い、StringComparisonやCompareOptionsで比較方法を柔軟に制御できます。

Unicode正規化やカルチャ依存の設定を適切に行うことで、多言語対応や表記ゆれにも強い検索が可能です。

パフォーマンス面ではSpan<char>の活用や並列処理が効果的で、セキュリティ面では誤検知や国際化の落とし穴に注意が必要です。

用途に応じて正規表現やサードパーティライブラリも検討しましょう。