文字列

【C#】String.CompareとStringComparisonで文字列の大小を正確に判定する方法

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

C#で文字列の大小を比べるなら、基本はstring.Compareを使い、結果が負なら左が小、0なら等しい、正なら左が大きいとなります。

大小関係を安定させたい場合はStringComparison.OrdinalかOrdinalIgnoreCaseを指定するとカルチャ違いの影響を避けられます。

単純な等価判定だけならstring.Equalsや==も使えますが、大文字小文字やカルチャを意識するなら比較方法を明示するのが安心です。

目次から探す

文字列比較の基本
StringComparison 列挙体の詳解
大文字小文字の扱い
- 厳密比較と無視比較の使い分け
- ToUpper／ToLower に頼らない理由
カルチャの影響
ソートでの応用
パフォーマンス最適化
Unicode と正規化
Null と空文字列
- Null セーフな比較パターン
- 空白・制御文字の前処理ポイント
検索・フィルタリング
多言語アプリケーションの注意点
よくあるバグと対策
.NET バージョン差異
便利なコードスニペット集
まとめ

文字列比較の基本

文字列の比較はプログラミングにおいて非常に頻繁に行われる操作です。

C#では複数の方法が用意されており、用途に応じて使い分けることが重要です。

ここでは、== 演算子、string.Equalsメソッド、string.Compareメソッド、そして StringComparerクラスの基本的な使い方と違いについて詳しく解説します。

== と string.Equals の違い

C#で文字列を比較する際に最も直感的に使われるのが == 演算子です。

== は文字列の内容を比較するように見えますが、実際にはオーバーロードされた演算子であり、文字列の値を比較します。

つまり、== は文字列の中身が同じかどうかを判定します。

一方、string.Equalsメソッドは、文字列の等価性を判定するためのメソッドで、より細かい比較オプションを指定できます。

特に、比較時に大文字・小文字の区別をするかどうかや、カルチャ(文化圏)に依存した比較を行うかどうかを指定できる点が特徴です。

以下のサンプルコードで違いを確認してみましょう。

using System;
class Program
{
    static void Main()
    {
        string str1 = "Hello";
        string str2 = "hello";
        // == 演算子による比較(大文字小文字を区別)
        bool result1 = (str1 == str2);
        Console.WriteLine($"== 演算子の比較結果: {result1}"); // false
        // string.Equals メソッド(大文字小文字を区別)
        bool result2 = string.Equals(str1, str2);
        Console.WriteLine($"string.Equals(区別あり)の比較結果: {result2}"); // false
        // string.Equals メソッド(大文字小文字を区別しない)
        bool result3 = string.Equals(str1, str2, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"string.Equals(区別なし)の比較結果: {result3}"); // true
    }
}

== 演算子の比較結果: False
string.Equals(区別あり)の比較結果: False
string.Equals(区別なし)の比較結果: True

この例では、== 演算子と string.Equals のデフォルト比較は大文字小文字を区別するため、"Hello" と "hello" は異なる文字列と判定されます。

しかし、string.Equals に StringComparison.OrdinalIgnoreCase を指定すると、大文字小文字を無視して比較できるため、等しいと判定されます。

まとめると、== 演算子は簡単に使えますが、大文字小文字の区別やカルチャを考慮した比較が必要な場合は、string.Equalsメソッドを使うことをおすすめします。

string.Compare の戻り値の読み取り方

string.Compareメソッドは、2つの文字列の大小関係を判定するために使います。

戻り値は整数で、比較結果を次のように表します。

負の値：最初の文字列が2番目の文字列より小さい
0：両方の文字列は等しい
正の値：最初の文字列が2番目の文字列より大きい

このメソッドは、単に等しいかどうかだけでなく、文字列の順序を判定したい場合に便利です。

例えば、ソート処理や辞書順の判定などで使われます。

以下のサンプルコードで使い方を確認しましょう。

using System;
class Program
{
    static void Main()
    {
        string str1 = "apple";
        string str2 = "banana";
        // 大文字小文字を区別しない比較
        int compareResult = string.Compare(str1, str2, StringComparison.OrdinalIgnoreCase);
        if (compareResult < 0)
        {
            Console.WriteLine($"{str1} は {str2} より小さい");
        }
        else if (compareResult > 0)
        {
            Console.WriteLine($"{str1} は {str2} より大きい");
        }
        else
        {
            Console.WriteLine($"{str1} と {str2} は等しい");
        }
    }
}

apple は banana より小さい

この例では、string.Compare が負の値を返しているため、"apple" は "banana" より辞書順で前にあることがわかります。

StringComparison.OrdinalIgnoreCase を指定しているので、大文字小文字の違いは無視して比較しています。

string.Compare は、比較方法を細かく指定できるため、カルチャに依存した比較や大文字小文字の区別を柔軟に切り替えられます。

戻り値の意味を正しく理解して使うことが大切です。

StringComparer クラスでの共通化

StringComparerクラスは、文字列の比較を行うための抽象クラスで、IComparer<string> と IEqualityComparer<string> の両方を実装しています。

これにより、ソートや辞書のキー比較など、さまざまな場面で一貫した文字列比較ルールを適用できます。

StringComparer には、あらかじめ用意された静的プロパティがあり、代表的な比較方法を簡単に取得できます。

プロパティ名	説明
`StringComparer.Ordinal`	バイナリ比較(大文字小文字を区別)
`StringComparer.OrdinalIgnoreCase`	バイナリ比較(大文字小文字を無視)
`StringComparer.CurrentCulture`	現在のカルチャに基づく比較(区別あり)
`StringComparer.CurrentCultureIgnoreCase`	現在のカルチャに基づく比較(区別なし)
`StringComparer.InvariantCulture`	不変カルチャに基づく比較(区別あり)
`StringComparer.InvariantCultureIgnoreCase`	不変カルチャに基づく比較(区別なし)

このクラスを使うと、例えば辞書のキー比較やリストのソートで同じ比較ルールを使い回せるため、コードの一貫性が保てます。

以下は、StringComparer を使って辞書のキー比較を行う例です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // 大文字小文字を区別しない比較を行う辞書を作成
        var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        dictionary["apple"] = "りんご";
        dictionary["Banana"] = "バナナ";
        // 大文字小文字が異なっても同じキーとして扱われる
        Console.WriteLine(dictionary.ContainsKey("APPLE")); // True
        Console.WriteLine(dictionary.ContainsKey("banana")); // True
        // 値の取得も大文字小文字を無視して可能
        Console.WriteLine(dictionary["APPLE"]); // りんご
    }
}

True
True
りんご

この例では、StringComparer.OrdinalIgnoreCase を指定して辞書を作成しているため、キーの大文字小文字を区別せずに検索や追加ができます。

StringComparer を使うことで、文字列比較のルールを一元管理でき、バグの発生を防ぎやすくなります。

また、リストのソートでも同様に使えます。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var fruits = new List<string> { "banana", "Apple", "cherry" };
        // 大文字小文字を区別しない順序でソート
        fruits.Sort(StringComparer.OrdinalIgnoreCase);
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

Apple
banana
cherry

このように、StringComparerクラスは文字列比較のルールを統一し、コードの可読性と保守性を高めるために役立ちます。

比較方法を明示的に指定したい場合は、StringComparer を活用するとよいでしょう。

StringComparison 列挙体の詳解

StringComparison 列挙体は、文字列比較の際にどのようなルールで比較を行うかを指定するために使います。

これにより、大文字小文字の区別やカルチャ(文化圏)に基づく比較の有無を細かく制御できます。

ここでは代表的な6つの値について詳しく説明します。

Ordinal と OrdinalIgnoreCase

Ordinal と OrdinalIgnoreCase は、文字列をバイナリレベルで比較する方法です。

つまり、文字のUnicodeコードポイントの値をそのまま比較します。

Ordinal は大文字小文字を区別して比較します
OrdinalIgnoreCase は大文字小文字を区別せずに比較します

この比較は高速で、カルチャに依存しないため、プログラム内部の識別子やファイル名の比較など、文化的な差異を考慮しない場面で使われます。

using System;
class Program
{
    static void Main()
    {
        string s1 = "café";
        string s2 = "café"; // 'e' + 結合文字(U+0301)
        // Ordinal 比較(大文字小文字区別あり)
        bool result1 = string.Equals(s1, s2, StringComparison.Ordinal);
        Console.WriteLine($"Ordinal 比較: {result1}"); // False
        // OrdinalIgnoreCase 比較(大文字小文字区別なし)
        bool result2 = string.Equals(s1.ToUpper(), s2.ToUpper(), StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"OrdinalIgnoreCase 比較: {result2}"); // False
        // 同じ文字列で大文字小文字区別なし比較
        string s3 = "Hello";
        string s4 = "hello";
        bool result3 = string.Equals(s3, s4, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"'Hello' と 'hello' の OrdinalIgnoreCase 比較: {result3}"); // True
    }
}

Ordinal 比較: False
OrdinalIgnoreCase 比較: False
'Hello' と 'hello' の OrdinalIgnoreCase 比較: True

この例では、s1 と s2 は見た目は同じ「café」ですが、Unicodeの正規化形式が異なるため、Ordinal 比較では異なる文字列と判定されます。

一方、OrdinalIgnoreCase は大文字小文字を無視しますが、正規化の違いは無視しません。

Ordinal 系の比較は高速で一貫性があるため、パフォーマンスが重要な場合や、文化的な差異を考慮しない比較に適しています。

CurrentCulture と CurrentCultureIgnoreCase

CurrentCulture と CurrentCultureIgnoreCase は、現在のスレッドのカルチャ(文化圏)に基づいて文字列を比較します。

これにより、言語や地域のルールに従った比較が可能です。

CurrentCulture は大文字小文字を区別して比較します
CurrentCultureIgnoreCase は大文字小文字を区別せずに比較します

例えば、日本語環境や英語環境での文字の並び順や等価性の判定が異なる場合に、この比較方法を使います。

using System;
using System.Globalization;
using System.Threading;
class Program
{
    static void Main()
    {
        string s1 = "straße"; // ドイツ語の「通り」
        string s2 = "strasse"; // 同じ意味の別表記
        // 現在のカルチャをドイツ語に設定
        Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
        // CurrentCulture 比較(大文字小文字区別あり)
        bool result1 = string.Equals(s1, s2, StringComparison.CurrentCulture);
        Console.WriteLine($"CurrentCulture 比較: {result1}"); // True
        // CurrentCultureIgnoreCase 比較(大文字小文字区別なし)
        bool result2 = string.Equals(s1.ToUpper(), s2.ToUpper(), StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"CurrentCultureIgnoreCase 比較: {result2}"); // True
        // カルチャを英語に変更
        Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
        bool result3 = string.Equals(s1, s2, StringComparison.CurrentCulture);
        Console.WriteLine($"en-US CurrentCulture 比較: {result3}"); // False
    }
}

CurrentCulture 比較: True
CurrentCultureIgnoreCase 比較: True
en-US CurrentCulture 比較: False

この例では、ドイツ語のカルチャでは「straße」と「strasse」が等しいと判定されますが、英語のカルチャでは異なる文字列と判定されます。

これは、ドイツ語の文化的なルールに基づく比較が行われているためです。

CurrentCulture 系の比較は、ユーザーの言語環境に合わせた文字列比較が必要な場合に使います。

ただし、カルチャ依存のため、環境が変わると結果が変わる可能性がある点に注意してください。

InvariantCulture と InvariantCultureIgnoreCase

InvariantCulture と InvariantCultureIgnoreCase は、カルチャに依存しない不変の文化圏(Invariant Culture)を使って比較します。

これは特定の言語や地域に依存しないため、安定した比較結果が得られます。

InvariantCulture は大文字小文字を区別して比較します
InvariantCultureIgnoreCase は大文字小文字を区別せずに比較します

この比較は、ログファイルの解析や設定ファイルの読み込みなど、文化的な差異を排除して一貫した比較が求められる場面で使われます。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string s1 = "İstanbul"; // トルコ語の大文字の点付きI
        string s2 = "istanbul";
        // InvariantCulture 比較(大文字小文字区別あり)
        bool result1 = string.Equals(s1, s2, StringComparison.InvariantCulture);
        Console.WriteLine($"InvariantCulture 比較: {result1}"); // False
        // InvariantCultureIgnoreCase 比較(大文字小文字区別なし)
        bool result2 = string.Equals(s1, s2, StringComparison.InvariantCultureIgnoreCase);
        Console.WriteLine($"InvariantCultureIgnoreCase 比較: {result2}"); // False
        // トルコ語カルチャで比較すると異なる結果になる
        var turkishCulture = new CultureInfo("tr-TR");
        bool result3 = string.Compare(s1, s2, true, turkishCulture) == 0;
        Console.WriteLine($"トルコ語カルチャで大文字小文字無視比較: {result3}"); // True
    }
}

InvariantCulture 比較: False
InvariantCultureIgnoreCase 比較: False
トルコ語カルチャで大文字小文字無視比較: True

この例では、トルコ語特有の大文字の点付きI(İ)と小文字のiの比較で、InvariantCulture では等しくないと判定されますが、トルコ語カルチャを指定すると等しいと判定されます。

InvariantCulture 系の比較は、文化的な差異を排除して一貫した比較を行いたい場合に適しています。

特に、システム内部の処理やログ解析などで使うとよいでしょう。

大文字小文字の扱い

文字列比較において大文字と小文字の区別は重要なポイントです。

用途によっては厳密に区別したい場合もあれば、区別せずに比較したい場合もあります。

ここでは、大文字小文字を区別する比較と区別しない比較の使い分けと、ToUpper／ToLowerメソッドに頼らない理由について説明します。

厳密比較と無視比較の使い分け

文字列の大文字小文字を区別するかどうかは、比較の目的によって使い分ける必要があります。

厳密比較(大文字小文字を区別)

ユーザーIDやパスワード、プログラムの識別子など、文字の大小が意味を持つ場合は厳密比較を行います。

例えば、"Admin" と "admin" は異なる文字列として扱うべきです。

無視比較(大文字小文字を区別しない)

ユーザーの入力や検索キーワード、ファイル名の比較など、大小文字の違いを無視して同じ意味として扱いたい場合に使います。

例えば、検索で "apple" と "Apple" を同じ結果として扱いたい場合です。

C#では、StringComparison 列挙体を使って比較方法を指定できます。

以下のサンプルコードで両者の違いを確認しましょう。

using System;
class Program
{
    static void Main()
    {
        string s1 = "Example";
        string s2 = "example";
        // 厳密比較(大文字小文字を区別)
        bool strictEqual = string.Equals(s1, s2, StringComparison.Ordinal);
        Console.WriteLine($"厳密比較: {strictEqual}"); // False
        // 無視比較(大文字小文字を区別しない)
        bool ignoreCaseEqual = string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"無視比較: {ignoreCaseEqual}"); // True
    }
}

厳密比較: False
無視比較: True

このように、StringComparison.Ordinal を使うと大文字小文字を区別して比較し、StringComparison.OrdinalIgnoreCase を使うと区別せずに比較できます。

用途に応じて適切な比較方法を選択してください。

ToUpper／ToLower に頼らない理由

大文字小文字を無視した比較を行う際に、文字列をすべて大文字や小文字に変換してから比較する方法があります。

しかし、この方法は推奨されません。

理由は以下の通りです。

カルチャ依存の問題

ToUpper() や ToLower() は現在のカルチャに依存して動作します。

例えば、トルコ語の「i」の大文字は「İ」(点付きI)であり、単純に変換すると意図しない結果になることがあります。

パフォーマンスの低下

文字列全体を変換するため、比較前に新しい文字列が生成されます。

大量の比較を行う場合、メモリ使用量や処理時間が増加します。

正規化の問題

Unicodeの結合文字やサロゲートペアを含む文字列では、単純な大文字小文字変換が正しく機能しない場合があります。

以下のサンプルコードは、ToUpper を使った比較と StringComparison.OrdinalIgnoreCase を使った比較の違いを示しています。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string s1 = "straße"; // ドイツ語の「通り」
        string s2 = "STRASSE";
        // ToUpper() を使った比較(カルチャ依存)
        bool toUpperEqual = s1.ToUpper().Equals(s2);
        Console.WriteLine($"ToUpper() 比較: {toUpperEqual}");
        // StringComparison.OrdinalIgnoreCase を使った比較
        bool ordinalIgnoreCaseEqual = string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"OrdinalIgnoreCase 比較: {ordinalIgnoreCaseEqual}");
    }
}

ToUpper() 比較: False
OrdinalIgnoreCase 比較: False

カルチャの影響

文字列比較においてカルチャ(文化圏)の違いは結果に大きな影響を与えます。

特に多言語対応のアプリケーションでは、カルチャ固有の文字の扱いや等価性を正しく理解しておくことが重要です。

ここではトルコ語の「I」と「i」の問題、ドイツ語の「ß」と「ss」の等価性、日本語のひらがな・カタカナ・全角半角の比較について説明します。

トルコ語の I と i 問題

トルコ語には大文字と小文字の「I」と「i」に関して、英語などとは異なる特殊なルールがあります。

英語では大文字の「I」に対応する小文字は「i」ですが、トルコ語では以下の4つの文字が区別されます。

大文字の「I」 (U+0049)
小文字の「ı」(点なし小文字アイ、U+0131)
大文字の「İ」(点付き大文字アイ、U+0130)
小文字の「i」(点付き小文字アイ、U+0069)

トルコ語のカルチャで大文字・小文字変換や比較を行うと、これらの文字はそれぞれ対応する文字に変換されます。

例えば、小文字の「i」を大文字に変換すると「İ」になり、大文字の「I」を小文字に変換すると「ı」になります。

このため、トルコ語カルチャでの文字列比較は他のカルチャと異なる結果になることがあります。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string s1 = "Istanbul"; // 大文字のIで始まる
        string s2 = "istanbul"; // 小文字のiで始まる
        var turkishCulture = new CultureInfo("tr-TR");
        // トルコ語カルチャで大文字小文字を無視して比較
        bool turkishEqual = string.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"トルコ語カルチャで比較: {turkishEqual}");
        // トルコ語カルチャを指定して比較
        bool turkishCompare = string.Compare(s1, s2, true, turkishCulture) == 0;
        Console.WriteLine($"トルコ語カルチャで Compare を使った比較: {turkishCompare}");
        // 英語カルチャで比較
        var englishCulture = new CultureInfo("en-US");
        bool englishCompare = string.Compare(s1, s2, true, englishCulture) == 0;
        Console.WriteLine($"英語カルチャで Compare を使った比較: {englishCompare}");
    }
}

トルコ語カルチャで比較: True
トルコ語カルチャで Compare を使った比較: False
英語カルチャで Compare を使った比較: True

この例では、StringComparison.CurrentCultureIgnoreCase を使った比較はトルコ語カルチャでも正しく動作し、、string.Compare にトルコ語カルチャを明示的に指定しても正しく比較できます。

トルコ語の「I」と「i」の扱いは特殊なので、多言語対応の際は注意が必要です。

ドイツ語 ß と ss の等価性

ドイツ語には「ß」(エスツェット)という特殊な文字があります。

これは「ss」と同じ音を表し、文字列比較においては等価とみなされることがあります。

例えば、「straße」(通り)と「strasse」は意味的には同じですが、Unicode上は異なる文字列です。

ドイツ語カルチャで比較すると、これらは等しいと判定される場合があります。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string s1 = "straße";
        string s2 = "strasse";
        var germanCulture = new CultureInfo("de-DE");
        // ドイツ語カルチャで大文字小文字を区別しない比較
        bool germanEqual = string.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"ドイツ語カルチャで比較: {germanEqual}"); // True
        // OrdinalIgnoreCase で比較(バイナリ比較)
        bool ordinalEqual = string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"OrdinalIgnoreCase で比較: {ordinalEqual}"); // False
    }
}

ドイツ語カルチャで比較: True
OrdinalIgnoreCase で比較: False

この例では、CurrentCultureIgnoreCase(ドイツ語カルチャ)を使うと「ß」と「ss」は等しいと判定されますが、OrdinalIgnoreCase(バイナリ比較)では異なる文字列と判定されます。

ドイツ語のようにカルチャ固有の等価性ルールがある場合は、適切なカルチャを指定して比較することが重要です。

日本語ひらがな・カタカナ・全角半角の比較

日本語の文字列比較では、ひらがなとカタカナ、全角と半角の違いが問題になることがあります。

これらはUnicode上は異なる文字として扱われますが、ユーザーの感覚では同じ文字として認識される場合があります。

例えば、「あ」(ひらがな)と「ア」(カタカナ)は別の文字ですが、検索やソートの際に同一視したいケースがあります。

また、「ｱ」(半角カタカナ)と「ア」(全角カタカナ)も同様です。

C#の標準的な文字列比較では、これらは区別されます。

カルチャに依存した比較を使っても、ひらがなとカタカナは等価とは判定されません。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string hiragana = "あ";
        string katakana = "ア";
        string hankakuKatakana = "ｱ";
        var japaneseCulture = new CultureInfo("ja-JP");
        // ひらがなとカタカナの比較
        bool hiraKataEqual = string.Equals(hiragana, katakana, StringComparison.CurrentCulture);
        Console.WriteLine($"ひらがなとカタカナの比較: {hiraKataEqual}");
        // 全角カタカナと半角カタカナの比較
        bool zenkakuHankakuEqual = string.Equals(katakana, hankakuKatakana, StringComparison.CurrentCulture);
        Console.WriteLine($"全角カタカナと半角カタカナの比較: {zenkakuHankakuEqual}");
        // ひらがなとカタカナを区別しない比較は標準ではできないため、正規化や変換が必要
    }
}

ひらがなとカタカナの比較: True
全角カタカナと半角カタカナの比較: True

標準の比較では区別されますが、日本語カルチャを指定した場合は、ひらがな・カタカナや全角・半角を同一視することが可能です。

まとめると、日本語の文字列比較ではカルチャ依存の比較だけでは不十分な場合が多く、用途に応じて文字列の正規化や変換を組み合わせることが求められます。

ソートでの応用

文字列のソートは多くのアプリケーションで必要な処理です。

C#ではカルチャに対応したソートや独自の比較ルールを適用することができ、より柔軟に文字列の並び順を制御できます。

ここでは、List のカルチャ対応ソート、IComparer<string> の自作、そして Dictionary のキー比較に StringComparer を指定する方法を解説します。

List をカルチャ対応で並べ替える

List<T> の Sortメソッドは、デフォルトで IComparable<T> に基づく比較を行いますが、文字列の場合はバイナリ比較(Ordinal)となるため、カルチャに依存した自然な並び順にはなりません。

日本語やドイツ語など特定の言語のルールに従ったソートを行いたい場合は、Sortメソッドに StringComparer を渡すことでカルチャ対応のソートが可能です。

以下は日本語カルチャを使ってリストをソートする例です。

using System;
using System.Collections.Generic;
using System.Globalization;
class Program
{
    static void Main()
    {
        var fruits = new List<string> { "りんご", "バナナ", "みかん", "ぶどう" };
        // 日本語カルチャの StringComparer を取得
        var comparer = StringComparer.Create(new CultureInfo("ja-JP"), ignoreCase: false);
        // カルチャ対応でソート
        fruits.Sort(comparer);
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

バナナ
ぶどう
みかん
りんご

この例では、日本語のカタカナとひらがなを含むリストを日本語カルチャに基づいてソートしています。

StringComparer.Create にカルチャと大文字小文字の無視設定を渡すことで、カルチャに適した比較ルールを適用できます。

IComparer<string> を自作してコレクションへ適用

より細かいルールや独自の比較基準が必要な場合は、IComparer<string> インターフェースを実装したクラスを作成して、List<T>.Sort や他のコレクションのソートに適用できます。

以下は、文字列の長さを優先して比較し、長さが同じ場合はカルチャ対応の辞書順で比較するカスタム比較器の例です。

using System;
using System.Collections.Generic;
using System.Globalization;
class LengthThenCultureComparer : IComparer<string>
{
    private readonly StringComparer cultureComparer;
    public LengthThenCultureComparer(CultureInfo culture)
    {
        cultureComparer = StringComparer.Create(culture, ignoreCase: false);
    }
    public int Compare(string x, string y)
    {
        if (x == null && y == null) return 0;
        if (x == null) return -1;
        if (y == null) return 1;
        int lengthComparison = x.Length.CompareTo(y.Length);
        if (lengthComparison != 0)
        {
            return lengthComparison;
        }
        // 長さが同じ場合はカルチャ対応の辞書順で比較
        return cultureComparer.Compare(x, y);
    }
}
class Program
{
    static void Main()
    {
        var words = new List<string> { "apple", "banana", "pear", "peach", "apricot" };
        var comparer = new LengthThenCultureComparer(new CultureInfo("en-US"));
        words.Sort(comparer);
        foreach (var word in words)
        {
            Console.WriteLine(word);
        }
    }
}

pear
peach
apple
banana
apricot

この例では、まず文字列の長さで比較し、長さが同じ場合は英語カルチャに基づく辞書順で並べ替えています。

IComparer<string> を自作することで、用途に応じた柔軟なソートルールを実装できます。

Dictionary のキー比較に StringComparer を指定

Dictionary<TKey, TValue> はキーの比較に IEqualityComparer<TKey> を使います。

文字列をキーにする場合、デフォルトは大文字小文字を区別する比較です。

大文字小文字を無視したい場合やカルチャに基づく比較をしたい場合は、StringComparer を指定して辞書を作成します。

以下は大文字小文字を無視してキーを扱う辞書の例です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        dictionary["Apple"] = "りんご";
        dictionary["BANANA"] = "バナナ";
        // 大文字小文字が異なっても同じキーとして扱われる
        Console.WriteLine(dictionary.ContainsKey("apple"));  // True
        Console.WriteLine(dictionary.ContainsKey("banana")); // True
        // 値の取得も大文字小文字を無視して可能
        Console.WriteLine(dictionary["APPLE"]);  // りんご
        Console.WriteLine(dictionary["banana"]); // バナナ
    }
}

True
True
りんご
バナナ

このように、StringComparer.OrdinalIgnoreCase を指定することで、キーの大文字小文字を区別せずに辞書を利用できます。

カルチャに依存した比較をしたい場合は、StringComparer.Create でカルチャを指定して辞書を作成することも可能です。

var cultureComparer = StringComparer.Create(new CultureInfo("ja-JP"), ignoreCase: true);
var dictionary = new Dictionary<string, string>(cultureComparer);

StringComparer を辞書のキー比較に使うことで、文字列の比較ルールを統一し、意図しないキーの重複や検索ミスを防げます。

パフォーマンス最適化

文字列比較は多くのアプリケーションで頻繁に行われる処理のため、パフォーマンスの最適化が重要です。

特に大量のデータを扱う場合やリアルタイム処理では、比較方法やメモリの使い方を工夫することで高速化やメモリ効率の向上が期待できます。

ここでは、Ordinal 比較の速度メリット、Span<char>／MemoryExtensions の活用、大量データ比較におけるメモリ計測について解説します。

Ordinal 比較の速度メリット

StringComparison.Ordinal および StringComparison.OrdinalIgnoreCase は、文字列をバイナリレベルで比較する方法です。

Unicodeコードポイントの値を直接比較するため、カルチャに依存する比較よりも高速に動作します。

カルチャ依存の比較は、言語や地域のルールに基づいて文字の等価性や順序を判定するため、内部で複雑な処理が行われます。

一方、Ordinal 比較は単純なバイト列の比較に近いため、CPUの命令を効率的に使え、パフォーマンスが向上します。

以下のサンプルコードは、Ordinal と CurrentCulture 比較の速度差を簡単に計測する例です。

using System;
using System.Diagnostics;
using System.Globalization;
class Program
{
    static void Main()
    {
        string s1 = "performanceTestString";
        string s2 = "performanceTestString";
        const int iterations = 10_000_000;
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            bool result = string.Equals(s1, s2, StringComparison.Ordinal);
        }
        sw.Stop();
        Console.WriteLine($"Ordinal 比較: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            bool result = string.Equals(s1, s2, StringComparison.CurrentCulture);
        }
        sw.Stop();
        Console.WriteLine($"CurrentCulture 比較: {sw.ElapsedMilliseconds} ms");
    }
}

Ordinal 比較: 150 ms
CurrentCulture 比較: 450 ms

(実行環境によって異なりますが、Ordinal 比較が約3倍高速になることが多いです)

このように、パフォーマンスが重要な場面では、可能な限り Ordinal 比較を使うことが推奨されます。

ただし、カルチャ依存の比較が必要な場合は正確性を優先してください。

Span<char>／MemoryExtensions の活用

.NET Core 以降や .NET Standard 2.1 以降では、Span<char> や MemoryExtensions を使って文字列の部分比較やメモリ効率の良い操作が可能です。

Span<char> はヒープ割り当てを伴わないスタックベースのメモリビューで、文字列のサブセットを効率的に扱えます。

MemoryExtensionsクラスには、Span<char> に対する比較メソッドが用意されており、SequenceEqual や StartsWith、EndsWith などが高速に実行できます。

以下は、Span<char> を使って部分文字列を比較する例です。

using System;
class Program
{
    static void Main()
    {
        string text = "Hello, World!";
        ReadOnlySpan<char> span = text.AsSpan();
        // "Hello" と比較
        ReadOnlySpan<char> target = "Hello".AsSpan();
        bool startsWith = span.Slice(0, 5).SequenceEqual(target);
        Console.WriteLine($"先頭が 'Hello' か: {startsWith}"); // True
        // 大文字小文字を無視した比較は自前で実装が必要
    }
}

先頭が 'Hello' か: True

Span<char> を使うことで、文字列の部分的な比較や切り出しを効率的に行え、不要な文字列のコピーや割り当てを減らせます。

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

ただし、Span<char> は大文字小文字を無視した比較を標準でサポートしていないため、その場合は別途実装が必要です。

大量データ比較でのメモリ計測

大量の文字列比較を行う場合、パフォーマンスだけでなくメモリ使用量も重要な指標です。

文字列のコピーや変換を多用するとGC(ガベージコレクション)が頻発し、パフォーマンス低下の原因になります。

例えば、ToUpper() や ToLower() を使って大文字小文字を無視した比較を行うと、新しい文字列が生成されるためメモリ消費が増えます。

一方、StringComparison.OrdinalIgnoreCase を使うと文字列のコピーは発生しません。

以下は、ToUpper() を使った比較と StringComparison.OrdinalIgnoreCase を使った比較でのメモリ使用量の違いを計測するサンプルコードです。

using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string s1 = "performanceTestString";
        string s2 = "PERFORMANCETESTSTRING";
        const int iterations = 1_000_000;
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        long beforeMemory = GC.GetTotalMemory(true);
        for (int i = 0; i < iterations; i++)
        {
            bool result = s1.ToUpper().Equals(s2);
        }
        long afterMemory = GC.GetTotalMemory(true);
        Console.WriteLine($"ToUpper() 比較でのメモリ増加: {afterMemory - beforeMemory} バイト");
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        beforeMemory = GC.GetTotalMemory(true);
        for (int i = 0; i < iterations; i++)
        {
            bool result = string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase);
        }
        afterMemory = GC.GetTotalMemory(true);
        Console.WriteLine($"OrdinalIgnoreCase 比較でのメモリ増加: {afterMemory - beforeMemory} バイト");
    }
}

ToUpper() 比較でのメモリ増加: 4376 バイト
OrdinalIgnoreCase 比較でのメモリ増加: 0 バイト

(数値は環境によって異なりますが、ToUpper() を使うと大量のメモリ割り当てが発生し、OrdinalIgnoreCase はほぼメモリ増加がありません)

このように、大量データの比較ではメモリ割り当てを抑えることがパフォーマンス向上に直結します。

StringComparison を活用し、不要な文字列変換を避けることが重要です。

パフォーマンスを意識した文字列比較では、Ordinal 系の比較を基本にしつつ、Span<char> を活用してメモリ効率を高め、大量データ処理時にはメモリ使用量の計測も行うことが効果的です。

Unicode と正規化

Unicode文字列の比較では、見た目が同じでも内部的に異なるコードポイントの組み合わせが存在するため、正規化や特殊文字の扱いに注意が必要です。

ここでは、Unicodeの正規化形式であるNFCとNFDの違い、サロゲートペアや絵文字の比較、異体字セレクタが混在する文字列の扱いについて解説します。

NFC と NFD の挙動差

Unicodeには同じ文字を表す複数の表現方法があり、これを統一するために「正規化(Normalization)」が用いられます。

主に使われる正規化形式はNFC(Normalization Form C)とNFD(Normalization Form D)です。

NFC(合成形式)

可能な限り複合文字(合成済みの1文字)で表現します。

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

NFD(分解形式)

文字を基本文字と結合文字に分解します。

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

この違いにより、同じ見た目の文字列でも内部的には異なるコード列となり、単純なバイナリ比較やOrdinal比較では異なる文字列と判定されます。

using System;
using System.Text;
class Program
{
    static void Main()
    {
        string composed = "é"; // U+00E9
        string decomposed = "e\u0301"; // 'e' + 結合アクセント
        Console.WriteLine($"composed == decomposed: {composed == decomposed}"); // False
        // NFC 正規化後の比較
        string normalizedComposed = composed.Normalize(NormalizationForm.FormC);
        string normalizedDecomposed = decomposed.Normalize(NormalizationForm.FormC);
        Console.WriteLine($"NFC 正規化後の比較: {normalizedComposed == normalizedDecomposed}"); // True
        // NFD 正規化後の比較
        normalizedComposed = composed.Normalize(NormalizationForm.FormD);
        normalizedDecomposed = decomposed.Normalize(NormalizationForm.FormD);
        Console.WriteLine($"NFD 正規化後の比較: {normalizedComposed == normalizedDecomposed}"); // True
    }
}

composed == decomposed: False
NFC 正規化後の比較: True
NFD 正規化後の比較: True

この例では、正規化を行わないと"é"(合成文字)と"e"＋結合アクセントは異なる文字列と判定されますが、NFCまたはNFDで正規化すると同じ文字列として扱えます。

文字列比較の前に正規化を行うことで、Unicodeの表現差異による誤判定を防げます。

サロゲートペア・絵文字の比較

UnicodeではBMP(基本多言語面)外の文字はサロゲートペアという2つの16ビットコードユニットで表現されます。

絵文字や一部の特殊文字はこのサロゲートペアに該当します。

C#のstringはUTF-16で内部表現されているため、サロゲートペアは2つのcharで構成されます。

これにより、文字列の長さやインデックス操作が直感的でない場合があります。

サロゲートペアを含む文字列の比較は、string.Compareやstring.Equalsで正しく行われますが、部分的にchar単位で処理すると誤判定の原因になります。

using System;
class Program
{
    static void Main()
    {
        string emoji1 = "😊"; // U+1F60A (サロゲートペア)
        string emoji2 = "\uD83D\uDE0A"; // サロゲートペアの2つのコードユニットで表現
        Console.WriteLine($"emoji1 == emoji2: {emoji1 == emoji2}"); // True
        Console.WriteLine($"emoji1.Length: {emoji1.Length}"); // 2
        Console.WriteLine($"emoji2.Length: {emoji2.Length}"); // 2
        // char単位での比較は不十分
        Console.WriteLine($"emoji1[0] == emoji2[0]: {emoji1[0] == emoji2[0]}"); // True
        Console.WriteLine($"emoji1[1] == emoji2[1]: {emoji1[1] == emoji2[1]}"); // True
    }
}

emoji1 == emoji2: True
emoji1.Length: 2
emoji2.Length: 2
emoji1[0] == emoji2[0]: True
emoji1[1] == emoji2[1]: True

この例では、絵文字はサロゲートペアで2文字分の長さを持ちますが、stringの比較は正しく等価と判定しています。

部分的にchar単位で処理すると誤解が生じるため、文字列全体で比較することが重要です。

異体字セレクタが混在する文字列

異体字セレクタ(Variation Selectors)は、同じ基本文字に対して異なる字体やスタイルを指定するUnicodeの特殊なコードポイントです。

例えば、漢字の異体字や絵文字のスタイル変更に使われます。

異体字セレクタが含まれる文字列は、見た目はほぼ同じでも内部的には異なるコード列となるため、単純な比較では異なる文字列と判定されることがあります。

using System;
using System.Text;

class Program
{
    static void Main()
    {
        // 「漢」＋異体字セレクタ1 (U+FE00)
        string variant1 = "漢\uFE00";
        // 「漢」＋異体字セレクタ2 (U+FE01)
        string variant2 = "漢\uFE01";
        Console.WriteLine($"variant1 == variant2: {variant1 == variant2}"); // False

        // 異体字セレクタを除去して比較する例
        string cleaned1 = RemoveVariationSelectors(variant1);
        string cleaned2 = RemoveVariationSelectors(variant2);
        Console.WriteLine($"異体字セレクタ除去後の比較: {cleaned1 == cleaned2}"); // True
    }

    static string RemoveVariationSelectors(string input)
    {
        var sb = new StringBuilder();
        for (int i = 0; i < input.Length; i++)
        {
            int codePoint;
            // UTF-16サロゲートペア判定
            if (char.IsHighSurrogate(input[i]) && i + 1 < input.Length && char.IsLowSurrogate(input[i + 1]))
            {
                codePoint = char.ConvertToUtf32(input[i], input[i + 1]);
                i++; // サロゲートペア分を1つ進める
            }
            else
            {
                codePoint = input[i];
            }

            if (!IsVariationSelector(codePoint))
            {
                // codePointをUTF-16に変換して StringBuilder に追加
                if (codePoint > 0xFFFF)
                {
                    sb.Append(char.ConvertFromUtf32(codePoint));
                }
                else
                {
                    sb.Append((char)codePoint);
                }
            }
        }
        return sb.ToString();
    }

    static bool IsVariationSelector(int codePoint)
    {
        // 異体字セレクタ1～16 (U+FE00～U+FE0F)
        if (codePoint >= 0xFE00 && codePoint <= 0xFE0F)
            return true;
        // 異体字セレクタ補助 (U+E0100～U+E01EF)
        if (codePoint >= 0xE0100 && codePoint <= 0xE01EF)
            return true;
        return false;
    }
}

variant1 == variant2: False
異体字セレクタ除去後の比較: True

この例では、異体字セレクタの違いにより文字列は異なると判定されますが、セレクタを除去すると同じ文字列として扱えます。

異体字セレクタを含む文字列を比較する場合は、用途に応じてセレクタを無視するかどうかを検討し、必要に応じて除去や正規化を行うことが望ましいです。

Null と空文字列

文字列比較を行う際、null や空文字列("")の扱いは非常に重要です。

これらを適切に処理しないと、例外が発生したり、意図しない比較結果になることがあります。

ここでは、null セーフな比較パターンと、空白や制御文字の前処理のポイントについて解説します。

Null セーフな比較パターン

null の文字列を比較すると、string.Equals や string.Compare は例外を投げずに安全に動作しますが、== 演算子やメソッドの使い方によっては NullReferenceException が発生することがあります。

例えば、== 演算子は null 同士の比較は問題ありませんが、メソッド呼び出しで null の文字列に対してインスタンスメソッドを使うと例外になります。

using System;
class Program
{
    static void Main()
    {
        string s1 = null;
        string s2 = "test";
        // == 演算子は null 安全
        Console.WriteLine(s1 == s2); // False
        Console.WriteLine(s1 == null); // True
        // string.Equals は null 安全
        Console.WriteLine(string.Equals(s1, s2)); // False
        Console.WriteLine(string.Equals(s1, null)); // True
        // インスタンスメソッドは null で例外になる
        try
        {
            bool result = s1.Equals(s2);
        }
        catch (NullReferenceException)
        {
            Console.WriteLine("NullReferenceException が発生しました");
        }
    }
}

False
True
False
True
NullReferenceException が発生しました

このように、string.Equals の静的メソッドを使うか、== 演算子を使うことで null セーフな比較が可能です。

インスタンスメソッドの Equals は null の文字列に対して呼び出すと例外になるため注意してください。

また、string.Compare も null を安全に扱えます。

null は空文字列よりも小さいとみなされます。

using System;
class Program
{
    static void Main()
    {
        string s1 = null;
        string s2 = "";
        int result = string.Compare(s1, s2, StringComparison.Ordinal);
        if (result < 0)
        {
            Console.WriteLine("null は空文字列より小さい");
        }
        else if (result == 0)
        {
            Console.WriteLine("null と空文字列は等しい");
        }
        else
        {
            Console.WriteLine("null は空文字列より大きい");
        }
    }
}

null は空文字列より小さい

この挙動を理解しておくと、null と空文字列の比較で意図しない結果を防げます。

空白・制御文字の前処理ポイント

文字列の比較前に空白や制御文字を取り除くことは、ユーザー入力の検証や検索機能でよく行われます。

特に、全角スペースやタブ、改行などの制御文字は見た目に影響しない場合でも比較結果に影響を与えます。

string.Trim() は先頭と末尾の空白文字を削除しますが、Unicodeの全角スペースや一部の制御文字は対象外の場合があります。

必要に応じて正規表現やカスタム処理で除去することが望ましいです。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input1 = "　テスト　"; // 全角スペースを含む
        string input2 = "テスト";
        // Trim() は全角スペースを削除しない
        Console.WriteLine($"Trim() 後: '{input1.Trim()}'"); // '　テスト　'
        // 正規表現で全角スペースと制御文字を削除
        string pattern = @"[\s\u3000]+"; // \s は半角空白・タブ・改行、\u3000 は全角スペース
        string cleaned = Regex.Replace(input1, pattern, "");
        Console.WriteLine($"正規表現で除去後: '{cleaned}'"); // 'テスト'
        // 比較例
        bool equal = string.Equals(cleaned, input2, StringComparison.Ordinal);
        Console.WriteLine($"比較結果: {equal}"); // True
    }
}

Trim() 後: '　テスト　'
正規表現で除去後: 'テスト'
比較結果: True

この例では、Trim() では全角スペースが削除されず、正規表現で全角スペースや半角空白をまとめて除去しています。

制御文字も同様に正規表現で除去可能です。

また、改行コード\r、\nやタブ\tなども比較前に除去や置換を検討してください。

これにより、ユーザー入力の揺らぎを吸収し、正確な比較が可能になります。

null と空文字列、空白や制御文字の扱いを適切に行うことで、文字列比較の信頼性と堅牢性が向上します。

特にユーザー入力や外部データを扱う場合は、これらの前処理を必ず検討してください。

検索・フィルタリング

文字列の検索やフィルタリングは、データ処理やユーザーインターフェースで頻繁に使われる機能です。

C#ではIndexOfメソッドとStringComparisonを組み合わせて柔軟な検索が可能であり、LINQを活用した動的なフィルタリングや、正規表現と文化的比較を併用した高度な検索も実現できます。

IndexOf と StringComparison の合わせ技

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

StringComparisonを指定することで、大文字小文字の区別やカルチャに依存した検索が可能です。

これにより、ユーザーの入力に対して柔軟な検索条件を設定できます。

以下は、大文字小文字を無視して部分文字列を検索する例です。

using System;
class Program
{
    static void Main()
    {
        string text = "C# Programming Language";
        string keyword = "programming";
        // 大文字小文字を無視して検索
        int index = text.IndexOf(keyword, StringComparison.OrdinalIgnoreCase);
        if (index >= 0)
        {
            Console.WriteLine($"キーワード '{keyword}' は位置 {index} に見つかりました。");
        }
        else
        {
            Console.WriteLine($"キーワード '{keyword}' は見つかりませんでした。");
        }
    }
}

キーワード 'programming' は位置 3 に見つかりました。

この例では、StringComparison.OrdinalIgnoreCaseを指定することで、"Programming"と"programming"の違いを無視して検索しています。

IndexOfは見つからなければ-1を返すため、条件分岐で存在チェックが可能です。

LINQ で動的フィルタを行う例

LINQを使うと、コレクションに対して動的に条件を組み合わせたフィルタリングが簡単に行えます。

文字列検索にIndexOfとStringComparisonを組み合わせることで、大文字小文字を無視した部分一致検索なども柔軟に実装できます。

以下は、複数のキーワードでフィルタリングを行う例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var items = new List<string>
        {
            "Apple Pie",
            "Banana Bread",
            "Cherry Tart",
            "apple tart",
            "banana split"
        };
        var keywords = new List<string> { "apple", "tart" };
        // キーワードのいずれかを含むアイテムを抽出(大文字小文字無視)
        var filtered = items.Where(item =>
            keywords.Any(keyword =>
                item.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0));
        foreach (var item in filtered)
        {
            Console.WriteLine(item);
        }
    }
}

Apple Pie
Cherry Tart
apple tart

この例では、keywordsリストのいずれかのキーワードが含まれるアイテムを抽出しています。

IndexOfにStringComparison.OrdinalIgnoreCaseを指定しているため、大文字小文字を区別せずに検索しています。

LINQのAnyメソッドを使うことで複数キーワードの動的な条件を簡潔に表現できます。

正規表現と文化的比較の併用

正規表現は複雑なパターンマッチングに強力ですが、デフォルトではカルチャに依存しないバイナリ比較を行います。

文化的な文字列比較を考慮したい場合は、正規表現のパターン設計とRegexOptionsの設定を工夫する必要があります。

例えば、日本語の全角・半角の違いや大文字小文字の違いを考慮した検索を行う場合、正規表現のパターンにUnicodeの文字クラスやオプションを組み合わせます。

以下は、大文字小文字を無視して英数字を検索する例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string text = "C# programming Language";
        string pattern = "programming";
        // RegexOptions.IgnoreCase で大文字小文字を無視
        var regex = new Regex(pattern, RegexOptions.IgnoreCase);
        bool isMatch = regex.IsMatch(text);
        Console.WriteLine($"正規表現によるマッチ: {isMatch}");
    }
}

正規表現によるマッチ: True

ただし、正規表現はカルチャ固有の等価性(例：ドイツ語のßとssの等価性など)を自動的には考慮しません。

必要に応じて、検索前に文字列を正規化したり、特定の文字を置換してから正規表現を適用する方法が有効です。

また、.NETの正規表現はUnicodeカテゴリーをサポートしているため、\p{IsHiragana}や\p{IsKatakana}などを使って日本語の文字種を指定することも可能です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string text = "これはテストです。";
        // ひらがなを含むかどうかを判定
        var regex = new Regex(@"\p{IsHiragana}+");
        bool containsHiragana = regex.IsMatch(text);
        Console.WriteLine($"ひらがなを含みます: {containsHiragana}");
    }
}

ひらがなを含みます: True

このように、正規表現と文化的比較を組み合わせることで、より高度で柔軟な文字列検索・フィルタリングが実現できます。

用途に応じて正規表現のパターン設計や前処理を工夫してください。

多言語アプリケーションの注意点

多言語対応のアプリケーションでは、文字列比較やソートの挙動が環境や設定によって異なることがあり、注意が必要です。

ここでは、WindowsとLinuxでのカルチャ差、InvariantCulture の採用判断、そしてユーザー指定カルチャを反映する設計について解説します。

Windows と Linux でのカルチャ差

.NETはクロスプラットフォーム対応が進んでいますが、WindowsとLinuxではカルチャの実装に違いがあります。

WindowsはネイティブのWindowsカルチャAPIを利用し、LinuxはICU(International Components for Unicode)ライブラリを使っています。

この違いにより、同じカルチャ名でも文字列比較やソートの結果が異なる場合があります。

例えば、ドイツ語の「ß」と「ss」の扱いや、トルコ語の「I」と「i」の大文字小文字変換など、WindowsとLinuxで微妙に異なる挙動を示すことがあります。

using System;
using System.Globalization;
using System.Runtime.InteropServices;
class Program
{
    static void Main()
    {
        var culture = new CultureInfo("de-DE");
        string s1 = "straße";
        string s2 = "strasse";
        bool equals = string.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"ドイツ語カルチャでの比較結果: {equals}");
        Console.WriteLine($"実行環境: {(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "Windows" : "Linux/その他")}");
    }
}

ドイツ語カルチャでの比較結果: False
実行環境: Windows

環境によっては"straße"と"strasse"が等しいと判定されることがありますすが、Linux環境では異なる結果になることがあります。

これにより、多言語対応アプリケーションで同じコードが異なる動作をするリスクがあるため、テストや動作確認が重要です。

InvariantCulture の採用判断

InvariantCultureは特定の言語や地域に依存しない不変のカルチャであり、安定した文字列比較やソートを提供します。

多言語アプリケーションで一貫した動作を保証したい場合に有効ですが、ユーザーの言語環境に合わせた表示や比較が必要な場合は適しません。

例えば、ログファイルの解析や内部処理、設定ファイルのキー比較など、文化的な差異を排除して一貫性を保ちたい場面でInvariantCultureを使います。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string s1 = "Istanbul";
        string s2 = "istanbul";
        bool invariantEqual = string.Equals(s1, s2, StringComparison.InvariantCultureIgnoreCase);
        Console.WriteLine($"InvariantCultureIgnoreCase での比較: {invariantEqual}");
    }
}

InvariantCultureIgnoreCase での比較: True

この例では、トルコ語特有の大文字小文字の違いを考慮しないため、"Istanbul" と "istanbul" は等しいと判定されます。

ユーザーの言語に依存した比較が必要な場合はInvariantCultureは適切でないことを理解して使い分けてください。

ユーザー指定カルチャを反映する設計

多言語アプリケーションでは、ユーザーが言語や地域の設定を変更できることが多く、そのカルチャ設定を文字列比較やソートに反映する設計が求められます。

これにより、ユーザーの期待に沿った自然な文字列処理が可能になります。

.NETでは、Thread.CurrentThread.CurrentCultureやCultureInfo.CurrentCultureを設定することで、カルチャ依存の比較やフォーマットが自動的に反映されます。

using System;
using System.Globalization;
using System.Threading;
class Program
{
    static void Main()
    {
        // ユーザーのカルチャを設定(例：日本語)
        Thread.CurrentThread.CurrentCulture = new CultureInfo("ja-JP");
        string s1 = "あいうえお";
        string s2 = "アイウエオ";
        bool equal = string.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"日本語カルチャでの比較結果: {equal}");
    }
}

日本語カルチャでの比較結果: False

ユーザーがカルチャを変更した場合は、アプリケーションの文字列比較やソート処理もそれに合わせて動的に切り替えることが望ましいです。

設定画面や初期化処理でカルチャを適切に設定し、CurrentCultureを利用した比較を行うことで、ユーザー体験を向上させられます。

多言語対応では、環境依存のカルチャ差異を理解し、InvariantCultureの使いどころを見極め、ユーザー指定カルチャを反映する設計を心がけることが重要です。

これにより、安定かつ自然な文字列処理を実現できます。

よくあるバグと対策

文字列比較やソートを扱う際には、特有の問題やバグが発生しやすいです。

特に多言語対応や並列処理を行う場合は注意が必要です。

ここでは、二重ソートで起こる順序不整合、カルチャ変更イベントへの耐性、並列処理で一致性を保つ方法について解説します。

二重ソートで起こる順序不整合

二重ソートとは、複数の条件で順序付けを行うことを指します。

例えば、まず名前でソートし、次に年齢でソートする場合などです。

しかし、文字列比較のカルチャや比較方法が異なると、二重ソートで順序が不整合になることがあります。

特に、1回目のソートと2回目のソートで異なるStringComparerやStringComparisonを使うと、同じ文字列に対して異なる比較結果が出てしまい、ソート結果が不安定になります。

using System;
using System.Collections.Generic;
using System.Globalization;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        var people = new List<Person>
        {
            new Person { Name = "äbc", Age = 30 },
            new Person { Name = "abc", Age = 25 },
            new Person { Name = "Äbc", Age = 20 }
        };
        // 1回目のソート：大文字小文字を区別しないカルチャ比較
        people.Sort((x, y) => string.Compare(x.Name, y.Name, CultureInfo.CurrentCulture, CompareOptions.IgnoreCase));
        // 2回目のソート：OrdinalIgnoreCaseでソート(異なる比較方法)
        people.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase));
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name} - {person.Age}");
        }
    }
}

abc - 25
Äbc - 20
äbc - 30

この例では、1回目と2回目のソートで比較方法が異なるため、順序が不整合になりやすいです。

対策としては、二重ソートを行う場合は同じ比較方法を使い、比較ルールを統一することが重要です。

また、LINQのThenByやThenByDescendingを使うと、比較方法を一貫させたまま複数条件のソートが可能です。

using System.Linq;
var sorted = people
    .OrderBy(p => p.Name, StringComparer.CurrentCultureIgnoreCase)
    .ThenBy(p => p.Age)
    .ToList();

カルチャ変更イベントへの耐性

.NETでは、CultureInfo.CurrentCultureはスレッドごとに設定されており、実行中に変更されることがあります。

アプリケーションの一部でカルチャが変更されると、文字列比較やソートの結果が変わり、予期しない動作やバグの原因になります。

特に長時間動作するサービスやマルチスレッド環境では、カルチャ変更に対する耐性が必要です。

対策としては、以下の方法があります。

カルチャを明示的に指定する

比較やソートの際にStringComparerやStringComparisonで明示的にカルチャを指定し、CurrentCultureに依存しないようにします。

カルチャの変更を監視し、必要に応じて再設定する

アプリケーションの設定やイベントでカルチャ変更を検知し、影響範囲を限定します。

スレッドごとにカルチャを固定する

スレッド開始時にカルチャを設定し、変更されないように管理します。

using System;
using System.Globalization;
using System.Threading;
class Program
{
    static void Main()
    {
        Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
        // カルチャを明示的に指定して比較
        string s1 = "straße";
        string s2 = "strasse";
        bool equal = string.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"比較結果: {equal}");
    }
}

このように、カルチャ変更の影響を受けにくい設計を心がけることが重要です。

並列処理で一致性を保つ方法

並列処理やマルチスレッド環境で文字列比較を行う場合、カルチャや比較ルールの一貫性を保つことが難しくなります。

スレッドごとにCurrentCultureが異なる場合や、比較方法が統一されていないと、結果が不安定になることがあります。

対策としては以下のポイントを押さえます。

比較ルールを明示的に指定する

StringComparisonやStringComparerを使い、カルチャや大文字小文字の区別を明確に指定します。

スレッドローカルなカルチャ設定を避けるか統一する

スレッドごとに異なるカルチャを設定しないか、必要に応じて統一します。

共有リソースへのアクセスを同期する

比較に使うカルチャや比較器がスレッドセーフであることを確認し、必要なら同期処理を行います。

以下は、並列処理でOrdinalIgnoreCaseを使って安全に比較する例です。

using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        string[] words = { "apple", "Apple", "APPLE", "banana", "BANANA" };
        Parallel.ForEach(words, word =>
        {
            bool isApple = string.Equals(word, "apple", StringComparison.OrdinalIgnoreCase);
            Console.WriteLine($"{word} は apple と {(isApple ? "等しい" : "異なる")}");
        });
    }
}

apple は apple と 等しい
Apple は apple と 等しい
APPLE は apple と 等しい
banana は apple と 異なる
BANANA は apple と 異なる
※マルチスレッドでの実行であるため、出力順序は実行毎に異なります

StringComparison.OrdinalIgnoreCaseはスレッドセーフで高速なため、並列処理での文字列比較に適しています。

これらのよくあるバグを理解し、比較方法の統一やカルチャ変更への耐性、並列処理での一貫性を確保することで、文字列比較に関するトラブルを未然に防げます。

.NET バージョン差異

.NETのバージョンによって、文字列比較やカルチャ処理の挙動に違いが存在します。

特に古い.NET Frameworkと最新の.NET 5/6/7、さらにモバイルやゲーム開発で使われるXamarinやUnityでは実装や動作が異なるため、開発時に注意が必要です。

.NET Framework 4.x 以前

.NET Framework 4.x以前のバージョンでは、文字列比較やカルチャ処理はWindowsのネイティブAPIに強く依存していました。

これにより、Windows環境での動作は安定していましたが、クロスプラットフォーム対応は限定的でした。

カルチャ依存の比較

String.CompareやString.EqualsはWindowsのNLS(National Language Support)APIを利用しており、カルチャごとの比較ルールはWindowsの実装に準拠していました。

パフォーマンス

一部の比較は現在の.NETに比べて遅く、特に大文字小文字を無視した比較やカルチャ依存の比較で顕著でした。

Unicode正規化の扱い

正規化のサポートは限定的で、Unicodeの結合文字やサロゲートペアの扱いに注意が必要でした。

クロスプラットフォーム非対応

LinuxやmacOSでの動作はサポートされておらず、Windows固有の挙動に依存していました。

このため、Windows専用のアプリケーションでは問題が少なかったものの、クロスプラットフォームや最新のUnicode対応が必要な場合は制約がありました。

.NET 5／6／7 の特徴

.NET 5以降は、.NET Coreの後継としてクロスプラットフォーム対応が強化され、文字列比較やカルチャ処理も大幅に改善されています。

ICUライブラリの採用

LinuxやmacOSではICU(International Components for Unicode)を利用してカルチャ処理を行い、Windowsとは異なる実装となっています。

これにより、カルチャ依存の比較結果がプラットフォーム間で異なる場合があります。

高速化と最適化

Ordinal系の比較はさらに高速化され、Span<char>やMemoryExtensionsを活用した効率的な文字列操作が可能です。

Unicode対応の強化

Unicodeの正規化やサロゲートペア、異体字セレクタの扱いが改善され、多言語対応がより正確になりました。

APIの統一と拡張

StringComparer.Createでカルチャと大文字小文字区別の設定を柔軟に指定でき、より細かい比較ルールの制御が可能です。

クロスプラットフォームの一貫性

ただし、WindowsとLinux/macOSでカルチャの挙動が異なるため、同じコードでも比較結果が異なることがあるため注意が必要です。

// .NET 5/6/7 でのカルチャ比較例
using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        var culture = new CultureInfo("de-DE");
        string s1 = "straße";
        string s2 = "strasse";
        bool equal = string.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"ドイツ語カルチャでの比較結果: {equal}");
    }
}

Xamarin と Unity での挙動比較

XamarinやUnityはモバイルやゲーム開発で広く使われるプラットフォームですが、.NETのフル機能をすべてサポートしているわけではありません。

文字列比較やカルチャ処理にも独自の制約や挙動差があります。

Xamarin

XamarinはMonoランタイムをベースにしており、.NET Frameworkや.NET Coreとは異なる実装を持ちます。

カルチャ処理はプラットフォームのネイティブAPIに依存することが多く、AndroidやiOSでの挙動が異なる場合があります。

Unicodeの正規化やカルチャ依存の比較は基本的にサポートされていますが、パフォーマンスや細かい挙動はプラットフォームに依存します
StringComparisonやStringComparerは利用可能ですが、最新の.NET Coreの最適化は反映されていないことがあります
Unity

Unityは独自のMonoベースのランタイムを使用しており、.NETの一部機能が制限されています。

特に古いバージョンのUnityでは、カルチャ依存の比較やUnicodeの扱いに制約があります。

Unityの標準環境ではStringComparisonの一部オプションがサポートされていない場合があります
カルチャ依存の比較は限定的で、Ordinal系の比較が推奨されることが多いです
最新のUnityバージョンでは.NET Standard 2.1や.NET Coreの機能が徐々に取り入れられていますが、完全な互換性はまだ課題です

// Xamarin/Unityでの比較例(基本的には.NET Frameworkと同様)
string s1 = "café";
string s2 = "café"; // 'e' + 結合文字
bool equal = string.Equals(s1, s2, StringComparison.Ordinal);
Console.WriteLine($"Ordinal 比較: {equal}"); // False
// 正規化を使うことが推奨される
equal = string.Equals(s1.Normalize(), s2.Normalize(), StringComparison.Ordinal);
Console.WriteLine($"正規化後の比較: {equal}"); // True

これらのバージョン差異を理解し、ターゲットプラットフォームに応じた文字列比較の実装やテストを行うことが、安定した多言語対応アプリケーション開発の鍵となります。

便利なコードスニペット集

文字列の大小判定やソート、パフォーマンス測定は日常的に行う処理です。

ここでは、最小構成で使える大小判定関数、カルチャ対応のソートテンプレート、そしてベンチマーク測定のサンプルコードを紹介します。

これらを活用することで、効率的に文字列比較処理を実装できます。

最小構成の大小判定関数

文字列の大小を判定する最小限の関数例です。

StringComparisonを引数に取り、柔軟に比較方法を指定できます。

戻り値は-1(小さい)、0(等しい)、1(大きい)で返します。

using System;
class StringCompareUtil
{
    public static int CompareStrings(string str1, string str2, StringComparison comparison = StringComparison.Ordinal)
    {
        if (str1 == null && str2 == null) return 0;
        if (str1 == null) return -1;
        if (str2 == null) return 1;
        int result = string.Compare(str1, str2, comparison);
        if (result < 0) return -1;
        if (result > 0) return 1;
        return 0;
    }
}
class Program
{
    static void Main()
    {
        Console.WriteLine(StringCompareUtil.CompareStrings("apple", "Banana", StringComparison.OrdinalIgnoreCase)); // -1
        Console.WriteLine(StringCompareUtil.CompareStrings("apple", "apple", StringComparison.Ordinal)); // 0
        Console.WriteLine(StringCompareUtil.CompareStrings(null, "apple")); // -1
        Console.WriteLine(StringCompareUtil.CompareStrings("banana", null)); // 1
    }
}

-1
0
-1
1

この関数はnull安全で、比較方法を柔軟に指定できるため、大小判定の基本として使いやすいです。

カルチャ対応ソートのテンプレート

カルチャに対応した文字列リストのソートを行うテンプレートです。

StringComparerを使い、カルチャと大文字小文字の区別を指定してソートします。

using System;
using System.Collections.Generic;
using System.Globalization;
class CultureAwareSorter
{
    public static void SortList(List<string> list, string cultureName = "en-US", bool ignoreCase = true)
    {
        var culture = new CultureInfo(cultureName);
        var comparer = StringComparer.Create(culture, ignoreCase);
        list.Sort(comparer);
    }
}
class Program
{
    static void Main()
    {
        var fruits = new List<string> { "りんご", "バナナ", "みかん", "ぶどう" };
        CultureAwareSorter.SortList(fruits, "ja-JP", ignoreCase: false);
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

バナナ
ぶどう
みかん
りんご

このテンプレートは、任意のカルチャで大文字小文字の区別を指定してソートできるため、多言語対応アプリケーションでの文字列ソートに便利です。

ベンチマーク測定サンプル

文字列比較のパフォーマンスを計測する簡単なベンチマークコードです。

Stopwatchを使い、指定回数の比較処理にかかる時間を測定します。

using System;
using System.Diagnostics;
class Benchmark
{
    public static void MeasureComparison(string s1, string s2, StringComparison comparison, int iterations = 10_000_000)
    {
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            bool result = string.Equals(s1, s2, comparison);
        }
        sw.Stop();
        Console.WriteLine($"{comparison}: {sw.ElapsedMilliseconds} ms");
    }
}
class Program
{
    static void Main()
    {
        string s1 = "performanceTestString";
        string s2 = "performanceteststring";
        Benchmark.MeasureComparison(s1, s2, StringComparison.Ordinal);
        Benchmark.MeasureComparison(s1, s2, StringComparison.OrdinalIgnoreCase);
        Benchmark.MeasureComparison(s1, s2, StringComparison.CurrentCulture);
        Benchmark.MeasureComparison(s1, s2, StringComparison.CurrentCultureIgnoreCase);
    }
}

Ordinal: 36 ms
OrdinalIgnoreCase: 61 ms
CurrentCulture: 730 ms
CurrentCultureIgnoreCase: 764 ms

(実行環境により異なります)

このサンプルを使うことで、比較方法ごとのパフォーマンス差を把握し、最適な比較方法を選択する参考になります。

これらのコードスニペットは、文字列比較の基本処理から多言語対応、パフォーマンス評価まで幅広く活用できるため、開発効率の向上に役立ちます。

まとめ

この記事では、C#における文字列比較の基本からカルチャ対応、パフォーマンス最適化、多言語環境での注意点まで幅広く解説しました。

StringComparisonやStringComparerを活用することで、大文字小文字の区別や文化圏に応じた正確な比較が可能になります。

また、Unicodeの正規化やサロゲートペアの扱い、環境依存の挙動差にも注意が必要です。

適切な比較方法を選び、パフォーマンスや多言語対応を考慮した設計が重要であることが理解できます。