C# String Contains() Method

What You’ll Learn

The instance method Contains() answers a simple question: does this string include a given piece of text? It returns true or false—perfect for validation, filtering, and conditional logic. You call it on the string being searched, not as a static method.

Definition and Usage

In C#, Contains() checks whether a substring appears anywhere within a string. It is an instance method, so you invoke it on the text you want to search: sentence.Contains("world").

The method returns a bool—no index, no new string. That makes it ideal for straightforward conditions like “does this email contain an @ symbol?” or “does this log line mention ERROR?” When you need the position of a match, use IndexOf() instead.

📝 Syntax

Common overloads on System.String:

public bool Contains(string value);
public bool Contains(string value, StringComparison comparisonType);
public bool Contains(char value);  // .NET 5+

Parameters

• value — the substring (or character) to search for. Must not be null for string overloads.
• comparisonType — how to compare: e.g. Ordinal, OrdinalIgnoreCase, CurrentCultureIgnoreCase.

Return Value

true if the substring is found anywhere in the string; false otherwise. Searching for an empty string "" always returns true.

Examples Gallery

Run with dotnet run. Each example shows a practical way to use Contains()—from basic checks to case rules, filtering, and comparison with IndexOf().

using System;

class Program {
    static void Main() {
        string mainString   = "C# programming is fun!";
        string searchString = "fun";

        bool found = mainString.Contains(searchString);

        Console.WriteLine($"Does the string contain '{searchString}'? {found}");
    }
}

Does the string contain 'fun'? True

using System;

class Program {
    static void Main() {
        string text = "Hello World";

        Console.WriteLine(text.Contains("world"));  // false — case mismatch
        Console.WriteLine(text.Contains("World"));  // true  — exact match
        Console.WriteLine(text.Contains("o W"));    // true  — middle substring
    }
}

False
True
True

using System;

class Program {
    static void Main() {
        string email = "User@Example.COM";

        bool hasAt = email.Contains(
            "@",
            StringComparison.OrdinalIgnoreCase);

        bool hasDomain = email.Contains(
            "example.com",
            StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"Has @ symbol: {hasAt}");
        Console.WriteLine($"Has example.com: {hasDomain}");
    }
}

Has @ symbol: True
Has example.com: True

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        string[] files = {
            "report-2024.pdf",
            "notes.txt",
            "report-draft.pdf",
            "photo.jpg"
        };

        List<string> reports = new List<string>();

        foreach (string file in files) {
            if (file.Contains("report", StringComparison.OrdinalIgnoreCase)) {
                reports.Add(file);
            }
        }

        Console.WriteLine("Report files:");
        foreach (string name in reports) {
            Console.WriteLine("  - " + name);
        }
    }
}

Report files:
  - report-2024.pdf
  - report-draft.pdf

using System;

class Program {
    static void Main() {
        string url = "https://codetofun.com/c-sharp";

        bool viaContains = url.Contains("/c-sharp");
        int  viaIndexOf  = url.IndexOf("/c-sharp");

        Console.WriteLine($"Contains: {viaContains}");
        Console.WriteLine($"IndexOf:  {viaIndexOf} (position)");

        if (viaIndexOf >= 0) {
            string section = url.Substring(viaIndexOf + 1);
            Console.WriteLine($"Section path: {section}");
        }
    }
}

Contains: True
IndexOf:  24 (position)
Section path: c-sharp

🚀 Common Use Cases

• Input validation — check that a password contains digits or special characters.
• Search and filter — find list items, filenames, or log lines matching a keyword.
• Feature flags in text — detect tags like [DEBUG] or ERROR: in messages.
• URL and path checks — verify a path segment or domain fragment is present.
• Guard clauses — skip processing when required text is missing: if (!data.Contains("id=")) return;

📝 Notes

• Default Contains(string) is ordinal and case-sensitive.
• Passing null as the search value throws ArgumentNullException.
• Searching for "" (empty string) always returns true.
• Prefer StringComparison.OrdinalIgnoreCase over ToLower() for case-insensitive checks—avoid extra string allocations.
• Contains(char) is available in .NET 5 and later for single-character checks.
• For “starts with” or “ends with” checks, use StartsWith() or EndsWith() instead—they express intent more clearly.

⚡ Optimization

Contains() is optimized for typical substring searches and is fine for most application code. If you call it repeatedly on the same large string with the same search term inside a hot loop, store the boolean result in a local variable instead of recomputing. For very large text or many patterns, consider Regex.IsMatch or specialized search libraries—but for simple keyword checks, Contains() remains the clearest choice.

💡 Best Practices