C# string.Containsの使い方完全ガイド｜大文字小文字の区別・部分一致・複数条件まで解説

はじめに

C#で文字列の中に特定の文字や単語が含まれているか調べたいときによく使うのが、string.Containsメソッドです。

たとえば、次のような処理で使われます。

C#
string text = "C# string.Containsの使い方を学びます";

bool result = text.Contains("Contains");

Console.WriteLine(result); // True

string.Containsはシンプルなメソッドですが、実際に使うと「大文字小文字は区別されるのか」「複数キーワードを判定するにはどうするのか」「nullの場合はどうなるのか」「IndexOfとの違いは何か」といった疑問が出てきます。

この記事では、C#のstring.Containsの基本から、大文字小文字を無視する方法、複数条件、null対策、List.Containsとの違い、実践的な使い方までまとめて解説します。

1. C#のstring.Containsとは？できることを最初に理解する

1-1. string.Containsは文字列に特定の文字・文字列が含まれるか判定するメソッド

string.Containsは、ある文字列の中に、指定した文字または文字列が含まれているかを調べるためのメソッドです。

Microsoftの公式ドキュメントでも、String.Containsは指定した文字列や文字が対象の文字列内に出現するかどうかを返すメソッドとして説明されています。Microsoft Learn+1

C#
string message = "Hello C#";

bool result = message.Contains("C#");

Console.WriteLine(result); // True

この例では、messageの中に"C#"が含まれているため、結果はtrueになります。

1-2. 戻り値はbool型｜含まれていればtrue、なければfalse

Containsの戻り値はbool型です。

つまり、結果は次のどちらかです。

C#
string text = "apple banana orange";

Console.WriteLine(text.Contains("banana")); // True
Console.WriteLine(text.Contains("grape"));  // False

Containsは「見つかった文字列そのもの」や「位置」を返すわけではありません。あくまで、含まれているかどうかをtrueまたはfalseで返します。

1-3. 完全一致ではなく「部分一致」を判定するメソッド

string.Containsは、完全一致ではなく部分一致を判定するメソッドです。

C#
string text = "programming";

Console.WriteLine(text.Contains("gram")); // True

"programming"と"gram"は完全には一致していませんが、"programming"の中に"gram"が含まれているため、trueになります。

完全一致を判定したい場合は、ContainsではなくEqualsや==を使います。

C#
string text = "programming";

Console.WriteLine(text == "gram");             // False
Console.WriteLine(text.Equals("programming")); // True

1-4. Containsがよく使われる場面｜検索・入力チェック・フィルタリング

string.Containsは、実務でも非常によく使われます。

代表的な用途は次のとおりです。

C#
string log = "ERROR: File not found";

if (log.Contains("ERROR"))
{
    Console.WriteLine("エラーが発生しています");
}

このように、Containsは「文字列の中に特定のキーワードがあるか」を調べる場面で便利です。

2. string.Containsの基本的な使い方

2-1. 文字列が含まれているか判定する基本構文

string.Containsの基本構文は次のとおりです。

C#
対象文字列.Contains(検索したい文字列)

例を見てみましょう。

C#
string text = "C# is fun";

bool contains = text.Contains("fun");

Console.WriteLine(contains); // True

textの中に"fun"が含まれているため、containsにはtrueが入ります。

2-2. 文字を1文字だけ検索する使い方

Containsでは、文字列だけでなく1文字の検索もできます。

C#
string text = "abcde";

bool result = text.Contains('c');

Console.WriteLine(result); // True

1文字を指定する場合は、ダブルクォーテーション"ではなく、シングルクォーテーション'を使います。

C#
text.Contains('c');   // char
text.Contains("c");   // string

どちらも似ていますが、'c'はchar型、"c"はstring型です。

2-3. if文と組み合わせた実用例

Containsは、if文と組み合わせて使うことが多いです。

C#
string input = "お問い合わせ内容にキャンセルという文字が含まれています";

if (input.Contains("キャンセル"))
{
    Console.WriteLine("キャンセル関連の問い合わせです");
}

Containsの結果はbool型なので、そのままif文の条件式として使えます。

C#
if (input.Contains("キャンセル"))
{
    // 含まれている場合の処理
}

2-4. 変数に検索キーワードを入れて判定する方法

検索したい文字列は、直接書くだけでなく変数に入れて使えます。

C#
string text = "C# string.Containsを学習中です";
string keyword = "Contains";

if (text.Contains(keyword))
{
    Console.WriteLine("キーワードが見つかりました");
}

検索ボックスや設定ファイルなどからキーワードを受け取る場合は、このように変数を使うのが一般的です。

C#
string keyword = Console.ReadLine();

if (text.Contains(keyword))
{
    Console.WriteLine("一致する内容があります");
}

ただし、ユーザー入力を使う場合は、空文字やnullにも注意が必要です。これについては後半で詳しく解説します。

2-5. 含まれていない場合の処理を書く方法

含まれていない場合の処理は、!を使って書けます。

C#
string text = "apple banana orange";

if (!text.Contains("grape"))
{
    Console.WriteLine("grapeは含まれていません");
}

または、elseを使って分岐することもできます。

C#
string text = "apple banana orange";

if (text.Contains("banana"))
{
    Console.WriteLine("bananaが含まれています");
}
else
{
    Console.WriteLine("bananaは含まれていません");
}

読みやすさを重視するなら、処理内容に合わせて!を使うかelseを使うかを選びましょう。

3. string.Containsは大文字小文字を区別する？仕様と対処法

3-1. 通常のContainsは大文字小文字を区別する

通常のContainsは、大文字小文字を区別します。

C#
string text = "Hello World";

Console.WriteLine(text.Contains("World")); // True
Console.WriteLine(text.Contains("world")); // False

"World"と"world"は、大文字のWと小文字のwが異なるため、結果はfalseになります。

C#でstring.Containsを使うときに特に多いミスが、この大文字小文字の違いです。

C#
string email = "USER@example.com";

Console.WriteLine(email.Contains("user")); // False

このような場合、大文字小文字を無視して比較する方法を使います。

3-2. StringComparison.OrdinalIgnoreCaseで大文字小文字を無視する方法

大文字小文字を無視してContainsしたい場合は、StringComparison.OrdinalIgnoreCaseを指定します。

C#
string text = "Hello World";

bool result = text.Contains("world", StringComparison.OrdinalIgnoreCase);

Console.WriteLine(result); // True

StringComparison.OrdinalIgnoreCaseを使うと、大小文字の違いを無視した比較ができます。

C#
string fileName = "Report.PDF";

if (fileName.Contains(".pdf", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("PDFファイルです");
}

ファイル名、拡張子、ID、コード値、ログなど、言語的な意味よりも機械的な一致を見たい場面では、OrdinalIgnoreCaseがよく使われます。

3-3. .NET Core／.NET 5以降で使えるContainsのオーバーロード

現在の.NETでは、ContainsにStringComparisonを指定できるオーバーロードが用意されています。公式ドキュメントにも、Contains(String, StringComparison)やContains(Char, StringComparison)が掲載されています。Microsoft Learn+1

C#
string text = "CSharp Programming";

bool result = text.Contains("csharp", StringComparison.OrdinalIgnoreCase);

Console.WriteLine(result); // True

この書き方は読みやすく、意図も明確です。

C#
text.Contains("keyword", StringComparison.OrdinalIgnoreCase)

大文字小文字を無視したい場合は、可能であればこの書き方を使うのがおすすめです。

3-4. .NET Frameworkで大文字小文字を無視したい場合はIndexOfを使う

.NET Frameworkでは、Contains(String, StringComparison)が使えない環境があります。その場合は、IndexOfを使って代替できます。

C#
string text = "Hello World";

bool result = text.IndexOf("world", StringComparison.OrdinalIgnoreCase) >= 0;

Console.WriteLine(result); // True

IndexOfは、指定した文字列が見つかった位置を返します。見つからない場合は-1を返すため、>= 0で判定できます。

C#
if (text.IndexOf("world", StringComparison.OrdinalIgnoreCase) >= 0)
{
    Console.WriteLine("見つかりました");
}

古い.NET Frameworkを使っている場合は、この方法を覚えておくと便利です。

3-5. ToLower／ToUpperで比較する方法が推奨されにくい理由

大文字小文字を無視するために、次のようなコードを書くこともできます。

C#
string text = "Hello World";

bool result = text.ToLower().Contains("world");

一見わかりやすいですが、この方法はあまり推奨されません。

理由は主に次の3つです。

特に、英語以外の文字列や国際化対応が必要なアプリでは、ToLowerやToUpperよりもStringComparisonを指定するほうが安全です。Microsoftの文字列比較のベストプラクティスでも、比較の目的に合ったStringComparisonを明示することが推奨されています。Microsoft Learn+1

4. StringComparisonの使い分け｜Ordinal・CurrentCulture・InvariantCulture

4-1. StringComparisonとは何か

StringComparisonは、文字列をどのルールで比較するかを指定する列挙型です。

たとえば、次のような指定があります。

C#
StringComparison.Ordinal
StringComparison.OrdinalIgnoreCase
StringComparison.CurrentCulture
StringComparison.CurrentCultureIgnoreCase
StringComparison.InvariantCulture
StringComparison.InvariantCultureIgnoreCase

公式ドキュメントでは、StringComparisonは現在のカルチャ、インバリアントカルチャ、序数比較、大文字小文字の扱いなど、文字列比較のルールを指定するための列挙型として説明されています。Microsoft Learn

4-2. 基本はOrdinalまたはOrdinalIgnoreCaseを選ぶ

多くのプログラムでは、基本的にOrdinalまたはOrdinalIgnoreCaseを選ぶとわかりやすいです。

C#
string text = "AdminUser";

bool result = text.Contains("admin", StringComparison.OrdinalIgnoreCase);

Ordinalは、文字を言語的な意味ではなく、コード値に近い形で比較します。

次のような用途では、Ordinal系が向いています。

たとえば、ログに"ERROR"が含まれているかを判定する場合は、カルチャ依存の比較よりもOrdinalIgnoreCaseのほうが意図が明確です。

C#
string log = "error: connection failed";

if (log.Contains("ERROR", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("エラーです");
}

4-3. ユーザー表示向けの文字列比較ではCurrentCultureを検討する

ユーザーが読む文章や、画面表示に近い文字列を比較する場合は、CurrentCultureやCurrentCultureIgnoreCaseを検討します。

C#
string title = "café menu";

bool result = title.Contains("CAFÉ", StringComparison.CurrentCultureIgnoreCase);

CurrentCultureは、現在のカルチャ、つまり実行環境やユーザー設定に応じたルールで比較します。

次のような場面では、CurrentCulture系を検討してもよいでしょう。

ただし、常にCurrentCultureを使えばよいわけではありません。ID、コード、ログ、内部処理では、Ordinal系のほうが適しています。

4-4. 日本語・英語・トルコ語などカルチャ差に注意する

文字列比較では、カルチャ差に注意が必要です。

特に有名なのが、トルコ語のIとiの問題です。英語圏の感覚では大文字小文字の対応が単純に見えても、カルチャによって変換や比較のルールが異なる場合があります。

そのため、次のように使い分けることが大切です。

C#
// 内部的な識別子やコード値
text.Contains(keyword, StringComparison.OrdinalIgnoreCase);

// ユーザー向けの自然な検索
text.Contains(keyword, StringComparison.CurrentCultureIgnoreCase);

日本語でも、全角・半角、ひらがな・カタカナ、濁点の扱いなど、単純なContainsだけでは期待通りに一致しない場合があります。

C#
string text = "カタカナ";

Console.WriteLine(text.Contains("かたかな")); // False

Containsは便利ですが、日本語の表記ゆれまで自動的に吸収するメソッドではありません。

4-5. 迷ったときのStringComparison選択早見表

迷ったときは、次の表を参考にしてください。

実務では、まずOrdinalまたはOrdinalIgnoreCaseを候補にし、ユーザー向け検索など必要な場合だけCurrentCulture系を検討するとよいでしょう。

5. 部分一致・前方一致・後方一致の違い

5-1. Containsは部分一致を判定する

Containsは、文字列のどこかに指定した文字列が含まれていればtrueを返します。

C#
string text = "Hello C# World";

Console.WriteLine(text.Contains("C#"));    // True
Console.WriteLine(text.Contains("Hello")); // True
Console.WriteLine(text.Contains("World")); // True

先頭にあっても、途中にあっても、末尾にあっても、含まれていればtrueです。

C#
string text = "abcdef";

Console.WriteLine(text.Contains("cd")); // True

このように、Containsは部分一致を判定したいときに使います。

5-2. 前方一致ならStartsWithを使う

文字列が特定の文字列で始まるかを判定したい場合は、StartsWithを使います。

C#
string text = "CSharpTutorial";

Console.WriteLine(text.StartsWith("CSharp")); // True
Console.WriteLine(text.StartsWith("Sharp"));  // False

Containsを使っても先頭に含まれるかのような判定はできますが、先頭であることを保証できません。

C#
string text = "MyCSharpTutorial";

Console.WriteLine(text.Contains("CSharp"));   // True
Console.WriteLine(text.StartsWith("CSharp")); // False

前方一致をしたい場合は、ContainsではなくStartsWithを使いましょう。

5-3. 後方一致ならEndsWithを使う

文字列が特定の文字列で終わるかを判定したい場合は、EndsWithを使います。

C#
string fileName = "sample.pdf";

Console.WriteLine(fileName.EndsWith(".pdf")); // True

ファイル拡張子の判定では、ContainsよりもEndsWithのほうが適しています。

C#
string fileName = "pdf_sample.txt";

Console.WriteLine(fileName.Contains(".pdf")); // False
Console.WriteLine(fileName.EndsWith(".pdf")); // False

ただし、次のようなケースではContainsだと誤判定する可能性があります。

C#
string fileName = "backup.pdf.txt";

Console.WriteLine(fileName.Contains(".pdf")); // True
Console.WriteLine(fileName.EndsWith(".pdf")); // False

「PDFという文字列を含むか」ではなく「PDFファイルか」を判定したいなら、EndsWithを使うべきです。

5-4. 完全一致ならEqualsまたは==を使う

文字列全体が一致するかどうかを判定したい場合は、Equalsまたは==を使います。

C#
string text = "admin";

Console.WriteLine(text.Contains("adm")); // True
Console.WriteLine(text == "adm");        // False
Console.WriteLine(text.Equals("admin")); // True

Containsは部分一致なので、完全一致の判定には向いていません。

大文字小文字を無視して完全一致したい場合は、EqualsにStringComparisonを指定します。

C#
string role = "Admin";

bool result = role.Equals("admin", StringComparison.OrdinalIgnoreCase);

Console.WriteLine(result); // True

5-5. Contains・StartsWith・EndsWith・Equalsの使い分け

文字列比較では、目的に合ったメソッドを選ぶことが重要です。

例で比較すると、次のようになります。

C#
string text = "CSharpGuide";

Console.WriteLine(text.Contains("Sharp"));     // True
Console.WriteLine(text.StartsWith("C"));       // True
Console.WriteLine(text.EndsWith("Guide"));     // True
Console.WriteLine(text.Equals("CSharpGuide")); // True

Containsは便利ですが、すべての文字列比較に使うものではありません。目的に応じて適切なメソッドを選びましょう。

6. 複数条件でContainsを使う方法

6-1. 複数キーワードのいずれかを含むか判定する

複数のキーワードのうち、どれか1つでも含まれていればよい場合は、||またはLINQのAnyを使います。

まずは||を使う基本例です。

C#
string text = "この商品は送料無料です";

if (text.Contains("無料") || text.Contains("送料無料"))
{
    Console.WriteLine("無料に関する文言が含まれています");
}

このコードでは、"無料"または"送料無料"のどちらかが含まれていればtrueになります。

6-2. 複数キーワードをすべて含むか判定する

複数のキーワードをすべて含むか判定したい場合は、&&またはLINQのAllを使います。

C#
string text = "C# string.Containsの使い方";

if (text.Contains("C#") && text.Contains("Contains"))
{
    Console.WriteLine("両方のキーワードが含まれています");
}

この場合、"C#"と"Contains"の両方が含まれている場合だけtrueになります。

6-3. ||と&&で条件を組み合わせる基本例

||は「または」、&&は「かつ」を意味します。

C#
string text = "ERROR: Database connection failed";

if (text.Contains("ERROR") || text.Contains("WARN"))
{
    Console.WriteLine("注意が必要なログです");
}

C#
string text = "ERROR: Database connection failed";

if (text.Contains("ERROR") && text.Contains("Database"))
{
    Console.WriteLine("データベース関連のエラーです");
}

条件が少ない場合は、||や&&で十分です。

ただし、キーワードが増えるとコードが長くなります。

C#
if (text.Contains("ERROR") ||
    text.Contains("WARN") ||
    text.Contains("FATAL") ||
    text.Contains("CRITICAL"))
{
    Console.WriteLine("重要なログです");
}

このような場合は、配列やListとLINQを使うとスッキリ書けます。

6-4. Anyを使って複数キーワードを簡潔に判定する

複数キーワードのうち、いずれかを含むか判定するならAnyが便利です。

C#
using System.Linq;

string text = "ERROR: Database connection failed";

string[] keywords = { "ERROR", "WARN", "FATAL" };

bool result = keywords.Any(keyword => text.Contains(keyword));

Console.WriteLine(result); // True

Anyは、条件を満たす要素が1つでもあればtrueを返します。

大文字小文字を無視したい場合は、次のように書きます。

C#
using System;
using System.Linq;

string text = "error: database connection failed";

string[] keywords = { "ERROR", "WARN", "FATAL" };

bool result = keywords.Any(keyword =>
    text.Contains(keyword, StringComparison.OrdinalIgnoreCase));

Console.WriteLine(result); // True

6-5. Allを使ってすべてのキーワードを含むか判定する

複数キーワードをすべて含むか判定する場合は、Allを使います。

C#
using System.Linq;

string text = "C# string.Contains tutorial";

string[] keywords = { "C#", "Contains", "tutorial" };

bool result = keywords.All(keyword => text.Contains(keyword));

Console.WriteLine(result); // True

Allは、すべての要素が条件を満たす場合だけtrueを返します。

C#
string[] keywords = { "C#", "Contains", "Java" };

bool result = keywords.All(keyword => text.Contains(keyword));

Console.WriteLine(result); // False

"Java"が含まれていないため、結果はfalseになります。

6-6. 複数条件が増えたときは配列・Listで管理する

キーワードが多い場合は、条件式に直接書くよりも、配列やListで管理したほうが保守しやすくなります。

C#
using System;
using System.Collections.Generic;
using System.Linq;

string text = "この投稿には禁止ワードが含まれています";

List<string> bannedWords = new List<string>
{
    "禁止ワード",
    "NG",
    "スパム"
};

bool hasBannedWord = bannedWords.Any(word =>
    text.Contains(word, StringComparison.OrdinalIgnoreCase));

if (hasBannedWord)
{
    Console.WriteLine("禁止ワードが含まれています");
}

キーワードの追加・削除が簡単になるため、実務ではこのような書き方がよく使われます。

7. null・空文字・例外に注意する

7-1. 対象文字列がnullだとNullReferenceExceptionになる

Containsを呼び出す対象の文字列がnullの場合、NullReferenceExceptionが発生します。

C#
string text = null;

bool result = text.Contains("test"); // NullReferenceException

Containsはインスタンスメソッドなので、nullに対して呼び出すことはできません。

そのため、対象文字列がnullになる可能性がある場合は、事前にチェックする必要があります。

C#
string text = null;

if (text != null && text.Contains("test"))
{
    Console.WriteLine("含まれています");
}

7-2. null条件演算子を使って安全に判定する

null条件演算子?.を使うと、より簡潔に書けます。

C#
string text = null;

bool result = text?.Contains("test") == true;

Console.WriteLine(result); // False

textがnullの場合、text?.Contains("test")はnullになります。

そのため、== trueを付けることで、trueの場合だけtrueになり、それ以外はfalseになります。

C#
if (text?.Contains("test") == true)
{
    Console.WriteLine("含まれています");
}

この書き方は、null安全にContainsを使いたいときに便利です。

7-3. string.IsNullOrEmptyと組み合わせる方法

対象文字列がnullまたは空文字でないことを確認してからContainsする方法もあります。

C#
string text = "";

if (!string.IsNullOrEmpty(text) && text.Contains("test"))
{
    Console.WriteLine("含まれています");
}

string.IsNullOrEmptyは、文字列がnullまたは""の場合にtrueを返します。

C#
Console.WriteLine(string.IsNullOrEmpty(null)); // True
Console.WriteLine(string.IsNullOrEmpty(""));   // True
Console.WriteLine(string.IsNullOrEmpty("abc")); // False

空文字を検索対象として扱いたくない場合は、IsNullOrEmptyを使うとよいでしょう。

7-4. string.IsNullOrWhiteSpaceと組み合わせる方法

空白だけの文字列も除外したい場合は、string.IsNullOrWhiteSpaceを使います。

C#
string text = "   ";

if (!string.IsNullOrWhiteSpace(text) && text.Contains("test"))
{
    Console.WriteLine("含まれています");
}

IsNullOrWhiteSpaceは、次のような値をtrueと判定します。

C#
string.IsNullOrWhiteSpace(null);  // True
string.IsNullOrWhiteSpace("");    // True
string.IsNullOrWhiteSpace("   "); // True

ユーザー入力を扱う場合は、IsNullOrEmptyよりもIsNullOrWhiteSpaceのほうが適していることがあります。

7-5. 検索文字列が空文字の場合の挙動

検索する文字列が空文字""の場合、Containsはtrueを返します。

C#
string text = "abc";

Console.WriteLine(text.Contains("")); // True

これは、空文字は任意の文字列に含まれると考えられるためです。

ただし、検索機能などでは、空文字を検索キーワードとして扱うと意図しない結果になることがあります。

C#
string keyword = "";

if (text.Contains(keyword))
{
    Console.WriteLine("一致しました");
}

この場合、ほぼ常に一致した扱いになってしまいます。

検索キーワードが空文字の場合は、事前にチェックするのがおすすめです。

C#
string keyword = "";

if (!string.IsNullOrWhiteSpace(keyword) &&
    text.Contains(keyword, StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("一致しました");
}

7-6. 安全なContains判定を共通メソッド化する例

nullや空文字に毎回注意するのが面倒な場合は、共通メソッド化すると便利です。

C#
using System;

public static class StringHelper
{
    public static bool SafeContains(string source, string keyword)
    {
        if (string.IsNullOrEmpty(source))
        {
            return false;
        }

        if (string.IsNullOrEmpty(keyword))
        {
            return false;
        }

        return source.Contains(keyword, StringComparison.OrdinalIgnoreCase);
    }
}

使う側はシンプルになります。

C#
string text = null;
string keyword = "test";

bool result = StringHelper.SafeContains(text, keyword);

Console.WriteLine(result); // False

大文字小文字を区別したい場合や、StringComparisonを外から指定したい場合は、次のようにできます。

C#
using System;

public static class StringHelper
{
    public static bool SafeContains(
        string source,
        string keyword,
        StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
    {
        if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(keyword))
        {
            return false;
        }

        return source.Contains(keyword, comparisonType);
    }
}

C#
bool result = StringHelper.SafeContains(
    "Hello World",
    "world",
    StringComparison.OrdinalIgnoreCase);

Console.WriteLine(result); // True

8. string.ContainsとList.Contains／Array.Containsの違い

8-1. string.Containsは文字列内の部分一致を調べる

string.Containsは、文字列の中に指定した文字列が含まれているかを調べます。

C#
string text = "apple banana orange";

bool result = text.Contains("banana");

Console.WriteLine(result); // True

この場合、"apple banana orange"という1つの文字列の中に"banana"が含まれるかを見ています。

つまり、string.Containsは「文字列内の部分一致」を調べるメソッドです。

8-2. List.Containsはリスト内の要素一致を調べる

一方、List.Containsは、リストの中に指定した要素が存在するかを調べます。

C#
using System.Collections.Generic;

List<string> fruits = new List<string>
{
    "apple",
    "banana",
    "orange"
};

bool result = fruits.Contains("banana");

Console.WriteLine(result); // True

これは、リストの要素として"banana"が存在するかを見ています。

部分一致ではありません。

C#
List<string> fruits = new List<string>
{
    "apple",
    "banana",
    "orange"
};

Console.WriteLine(fruits.Contains("ban")); // False

"banana"の中に"ban"は含まれていますが、リストの要素として"ban"は存在しないためfalseになります。

8-3. 配列でContainsを使うにはLINQが必要

配列でContainsを使う場合は、LINQを使います。

C#
using System.Linq;

string[] fruits = { "apple", "banana", "orange" };

bool result = fruits.Contains("banana");

Console.WriteLine(result); // True

using System.Linq;がないと、配列に対するContainsが使えない場合があります。

C#
using System.Linq;

配列のContainsも、基本的には要素一致です。

C#
string[] fruits = { "apple", "banana", "orange" };

Console.WriteLine(fruits.Contains("ban")); // False

部分一致をしたい場合は、Anyとstring.Containsを組み合わせます。

C#
using System.Linq;

string[] fruits = { "apple", "banana", "orange" };

bool result = fruits.Any(fruit => fruit.Contains("ban"));

Console.WriteLine(result); // True

8-4. 「文字列に含まれる」と「コレクションに含まれる」の違い

Containsという名前は同じでも、対象によって意味が違います。

次の違いを押さえておきましょう。

C#
string text = "banana";
Console.WriteLine(text.Contains("ban")); // True

C#
List<string> list = new List<string> { "banana" };
Console.WriteLine(list.Contains("ban")); // False

string.Containsは部分一致ですが、List.Containsは要素一致です。

8-5. 初心者が混同しやすいContainsの使い分け

初心者がよく混同するのは、次のようなケースです。

C#
List<string> names = new List<string>
{
    "Tanaka",
    "Yamada",
    "Suzuki"
};

bool result = names.Contains("aka");

Console.WriteLine(result); // False

"Tanaka"には"aka"が含まれていますが、リストの要素として"aka"は存在しないためfalseになります。

リスト内の各文字列に部分一致したい場合は、次のように書きます。

C#
using System.Linq;

List<string> names = new List<string>
{
    "Tanaka",
    "Yamada",
    "Suzuki"
};

bool result = names.Any(name => name.Contains("aka"));

Console.WriteLine(result); // True

つまり、次のように考えるとわかりやすいです。

9. Containsでできないことと代替方法

9-1. 複雑なパターン検索にはRegexを使う

Containsは単純な部分一致には便利ですが、複雑なパターン検索には向いていません。

たとえば、次のような判定です。

このような場合は、正規表現を使うRegexを検討します。

C#
using System.Text.RegularExpressions;

string text = "注文番号は123です";

bool result = Regex.IsMatch(text, @"\d{3}");

Console.WriteLine(result); // True

Containsは、あくまで指定した文字列が含まれるかを見るメソッドです。正規表現のようなパターン検索はできません。

9-2. 位置を知りたい場合はIndexOfを使う

Containsは、含まれているかどうかだけを返します。

文字列がどの位置にあるかを知りたい場合は、IndexOfを使います。IndexOfは、指定した文字列が最初に見つかった位置を返し、見つからない場合は-1を返します。Microsoft Learn+1

C#
string text = "Hello World";

int index = text.IndexOf("World");

Console.WriteLine(index); // 6

見つかったかどうかだけを知りたい場合はContains、位置も必要な場合はIndexOfを使いましょう。

C#
string text = "Hello World";

if (text.IndexOf("World") >= 0)
{
    Console.WriteLine("見つかりました");
}

ただし、単純に存在確認だけならContainsのほうが読みやすいです。Microsoftのコード分析ルールでも、IndexOfの結果を使って存在確認だけをしている場合は、読みやすさのためにContainsの使用が提案されています。Microsoft Learn

9-3. 置換したい場合はReplaceを使う

特定の文字列を別の文字列に置き換えたい場合は、ContainsではなくReplaceを使います。

C#
string text = "Hello World";

string replaced = text.Replace("World", "C#");

Console.WriteLine(replaced); // Hello C#

Containsと組み合わせて、存在する場合だけ置換することもできます。

C#
string text = "Hello World";

if (text.Contains("World"))
{
    text = text.Replace("World", "C#");
}

Console.WriteLine(text); // Hello C#

ただし、Replaceは対象が見つからない場合でも元の文字列と同じ内容を返すため、単純な置換だけなら事前にContainsを使わなくても問題ないことが多いです。

9-4. 分割して判定したい場合はSplitを使う

カンマ区切りやスペース区切りの文字列を分割してから判定したい場合は、Splitを使います。

C#
string csv = "apple,banana,orange";

string[] fruits = csv.Split(',');

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

単純にContainsを使うと、意図しない一致が起きる場合があります。

C#
string csv = "apple,banana,orange";

Console.WriteLine(csv.Contains("app")); // True

これは"apple"の一部に"app"が含まれているためです。

要素として完全一致したい場合は、分割してから判定します。

C#
using System.Linq;

string csv = "apple,banana,orange";

bool result = csv.Split(',').Contains("apple");

Console.WriteLine(result); // True

9-5. 大量データ検索ではパフォーマンスに注意する

Containsは便利ですが、大量データに対して何度も実行すると、パフォーマンスに影響することがあります。

たとえば、数十万件のデータを毎回全件走査してContainsするような処理です。

C#
var results = items.Where(item => item.Name.Contains(keyword)).ToList();

このような処理が必ず悪いわけではありませんが、データ量が増えると時間がかかる可能性があります。

大量データを扱う場合は、次のような対策を検討します。

小規模な文字列判定ならContainsで十分ですが、大規模検索では設計も重要です。

10. 実践例で学ぶstring.Contains

10-1. 入力値に禁止ワードが含まれているかチェックする

ユーザー投稿や問い合わせフォームでは、禁止ワードのチェックにContainsを使えます。

C#
using System;
using System.Linq;

string input = "この文章には禁止ワードが含まれています";

string[] bannedWords = { "禁止ワード", "スパム", "NG" };

bool hasBannedWord = bannedWords.Any(word =>
    input.Contains(word, StringComparison.OrdinalIgnoreCase));

if (hasBannedWord)
{
    Console.WriteLine("禁止ワードが含まれています");
}
else
{
    Console.WriteLine("問題ありません");
}

禁止ワードが増える場合は、配列やListで管理すると保守しやすくなります。

10-2. ファイル名や拡張子に特定文字列が含まれるか判定する

ファイル名に特定の文字列が含まれているかを判定できます。

C#
string fileName = "2026_report_final.pdf";

if (fileName.Contains("report", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("レポートファイルです");
}

ただし、拡張子を判定するならContainsよりEndsWithのほうが適しています。

C#
string fileName = "2026_report_final.pdf";

if (fileName.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("PDFファイルです");
}

Contains(".pdf")だと、"sample.pdf.txt"のようなファイルも一致してしまう可能性があります。

10-3. メールアドレスに特定ドメインが含まれるか判定する

メールアドレスに特定のドメインが含まれるかを確認できます。

C#
string email = "user@example.com";

if (email.Contains("@example.com", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("example.comのメールアドレスです");
}

ただし、ドメイン判定ではEndsWithのほうが適している場合があります。

C#
string email = "user@example.com";

if (email.EndsWith("@example.com", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("example.comのメールアドレスです");
}

Containsは途中に含まれていても一致するため、厳密な判定が必要な場合は注意しましょう。

10-4. 検索ボックスのキーワードでデータを絞り込む

検索ボックスに入力されたキーワードで一覧を絞り込む処理にもContainsが使えます。

C#
using System;
using System.Collections.Generic;
using System.Linq;

var products = new List<string>
{
    "C#入門書",
    "JavaScript実践ガイド",
    "ASP.NET Core開発",
    "Pythonデータ分析"
};

string keyword = "C#";

var results = products
    .Where(product => product.Contains(keyword, StringComparison.OrdinalIgnoreCase))
    .ToList();

foreach (var product in results)
{
    Console.WriteLine(product);
}

検索キーワードが空の場合は、全件表示するなどの処理に分けると自然です。

C#
if (string.IsNullOrWhiteSpace(keyword))
{
    Console.WriteLine("キーワードが空です");
}
else
{
    var results = products
        .Where(product => product.Contains(keyword, StringComparison.OrdinalIgnoreCase))
        .ToList();
}

10-5. ログ文字列にエラー文言が含まれるか判定する

ログ解析でもContainsはよく使われます。

C#
string log = "[2026-06-15 10:00:00] ERROR Connection failed";

if (log.Contains("ERROR"))
{
    Console.WriteLine("エラーログです");
}

大文字小文字が揺れる可能性がある場合は、OrdinalIgnoreCaseを指定します。

C#
string log = "[2026-06-15 10:00:00] error connection failed";

if (log.Contains("ERROR", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("エラーログです");
}

複数のログレベルを判定する場合は、Anyを使うと簡潔です。

C#
using System;
using System.Linq;

string log = "[2026-06-15 10:00:00] fatal system error";

string[] levels = { "ERROR", "FATAL", "CRITICAL" };

bool isImportant = levels.Any(level =>
    log.Contains(level, StringComparison.OrdinalIgnoreCase));

if (isImportant)
{
    Console.WriteLine("重要なログです");
}

11. string.Containsのよくあるエラー・つまずきポイント

11-1. 大文字小文字の違いでfalseになる

よくあるつまずきが、大文字小文字の違いです。

C#
string text = "CSharp";

Console.WriteLine(text.Contains("csharp")); // False

通常のContainsは大文字小文字を区別するため、"CSharp"と"csharp"は一致しません。

対策として、StringComparison.OrdinalIgnoreCaseを指定します。

C#
string text = "CSharp";

Console.WriteLine(text.Contains("csharp", StringComparison.OrdinalIgnoreCase)); // True

11-2. 全角・半角の違いで一致しない

全角と半角は別の文字として扱われます。

C#
string text = "ＡＢＣ";

Console.WriteLine(text.Contains("ABC")); // False

見た目が似ていても、全角の"Ａ"と半角の"A"は異なります。

必要に応じて、事前に文字列を正規化したり、全角半角変換を行ったりする必要があります。

C#
string text = "ＡＢＣ";
string keyword = "ABC";

// Containsだけでは全角半角の違いは吸収できない
Console.WriteLine(text.Contains(keyword)); // False

Containsは表記ゆれを自動的に吸収するメソッドではない点に注意しましょう。

11-3. 前後の空白が原因で一致しない

検索文字列や対象文字列に余分な空白があると、一致しないことがあります。

C#
string text = "apple";
string keyword = " apple ";

Console.WriteLine(text.Contains(keyword)); // False

ユーザー入力を使う場合は、Trimで前後の空白を削除するとよいでしょう。

C#
string text = "apple";
string keyword = " apple ";

keyword = keyword.Trim();

Console.WriteLine(text.Contains(keyword)); // True

検索ボックスの入力では、TrimとIsNullOrWhiteSpaceを組み合わせると安全です。

C#
string keyword = " apple ";
keyword = keyword.Trim();

if (!string.IsNullOrWhiteSpace(keyword) &&
    text.Contains(keyword, StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("見つかりました");
}

11-4. nullチェックを忘れて例外になる

対象文字列がnullの状態でContainsを呼び出すと、例外になります。

C#
string text = null;

Console.WriteLine(text.Contains("abc")); // NullReferenceException