How to check if a string contains a substring in C#

string message = "Build failed: 3 errors, 1 warning";

// string.Contains(string) returns a bool
Console.WriteLine(message.Contains("failed"));
Console.WriteLine(message.Contains("passed"));

// It is case-sensitive: "Failed" is not "failed"
Console.WriteLine(message.Contains("Failed"));

// Contains(char) checks for a single character (.NET Core 2.1+)
Console.WriteLine(message.Contains(':'));

if (message.Contains("error"))
{
    Console.WriteLine("Found an error in the build log");
}

// The empty string is contained in every string
Console.WriteLine(message.Contains(""));

// A null argument throws ArgumentNullException
try
{
    string? needle = null;
    message.Contains(needle!);
}
catch (ArgumentNullException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

// Calling Contains on a null string throws NullReferenceException,
// so guard a value that may be null with ?. and ??
string? log = null;
Console.WriteLine(log?.Contains("error") ?? false);

using System.Globalization;

string title = "Learning C# with CompileBytes";

// .NET Core 2.1+ / .NET 5+: pass a StringComparison
Console.WriteLine(title.Contains("compilebytes"));
Console.WriteLine(title.Contains("compilebytes", StringComparison.OrdinalIgnoreCase));
Console.WriteLine(title.Contains("LEARNING c#", StringComparison.OrdinalIgnoreCase));

// .NET Framework has no such overload: IndexOf with a comparison works everywhere
Console.WriteLine(title.IndexOf("compilebytes", StringComparison.OrdinalIgnoreCase) >= 0);

// A reusable extension method (see the type below)
Console.WriteLine(title.ContainsIgnoreCase("WITH"));

// Lowercasing both sides allocates two new strings and depends on the culture
Console.WriteLine(title.ToLower().Contains("compilebytes"));

// The Turkish-I problem: in tr-TR, "I" lowercases to a dotless "ı"
var turkish = new CultureInfo("tr-TR");
string file = "CONFIG.INI";
Console.WriteLine(file.ToLower(turkish));
Console.WriteLine(file.ToLower(turkish).Contains("config"));
Console.WriteLine(file.Contains("config", StringComparison.OrdinalIgnoreCase));

static class StringExtensions
{
    public static bool ContainsIgnoreCase(this string source, string value) =>
        source.Contains(value, StringComparison.OrdinalIgnoreCase);
}

using System.Globalization;

// Each case: a text, a needle, and what makes the pair interesting
(string Text, string Needle, string Label)[] cases =
[
    ("Hello World", "world", "case only"),
    ("caf\u00E9 menu", "cafe\u0301", "é vs e + accent"),
    ("co\u00ADoperate", "coop", "soft hyphen"),
    ("Stra\u00DFe", "STRASSE", "ß vs SS"),
];

StringComparison[] modes =
[
    StringComparison.Ordinal,
    StringComparison.OrdinalIgnoreCase,
    StringComparison.InvariantCulture,
    StringComparison.InvariantCultureIgnoreCase,
];

string[] headers = ["Ordinal", "OrdinalIC", "Invariant", "InvariantIC"];
Console.WriteLine($"{"case",-16} {string.Concat(headers.Select(h => $"{h,-12}"))}".TrimEnd());
foreach (var (text, needle, label) in cases)
{
    var results = modes.Select(m => $"{text.Contains(needle, m),-12}");
    Console.WriteLine($"{label,-16} {string.Concat(results)}".TrimEnd());
}

// Watch the defaults: Contains(string) is ordinal, IndexOf(string) uses the current culture
string word = "co\u00ADoperate";
Console.WriteLine(word.Contains("coop"));
Console.WriteLine(word.IndexOf("coop"));
Console.WriteLine(word.IndexOf("coop", StringComparison.Ordinal));

// A specific culture: Turkish ignore-case does not match I with i
var turkish = new CultureInfo("tr-TR");
Console.WriteLine(turkish.CompareInfo.IndexOf("TITLE", "title", CompareOptions.IgnoreCase));
Console.WriteLine(turkish.CompareInfo.IndexOf("T\u0130TLE", "title", CompareOptions.IgnoreCase));

string path = "/var/log/app/app.log";

// IndexOf returns the position of the first match, or -1 when there is none
Console.WriteLine(path.IndexOf("app", StringComparison.Ordinal));
Console.WriteLine(path.LastIndexOf("app", StringComparison.Ordinal));
Console.WriteLine(path.IndexOf("tmp", StringComparison.Ordinal));
Console.WriteLine(path.IndexOf('/', 1));   // char overload, starting at index 1

// Use the position: the file name is everything after the last '/'
int slash = path.LastIndexOf('/');
Console.WriteLine(path[(slash + 1)..]);

// StartsWith and EndsWith check one end only
Console.WriteLine(path.StartsWith("/var", StringComparison.Ordinal));
Console.WriteLine(path.EndsWith(".LOG", StringComparison.OrdinalIgnoreCase));

// Every position of a substring
string text = "the cat sat on the mat with the hat";
List<int> positions = AllIndexesOf(text, "the");
Console.WriteLine($"\"the\" at [{string.Join(", ", positions)}], count {positions.Count}");

// The loop moves on by one character, so overlapping matches count
Console.WriteLine(AllIndexesOf("aaaa", "aa").Count);

// Split counts non-overlapping matches: occurrences = pieces - 1
Console.WriteLine(text.Split("at").Length - 1);
Console.WriteLine("aaaa".Split("aa").Length - 1);

static List<int> AllIndexesOf(string text, string value)
{
    var positions = new List<int>();
    int index = text.IndexOf(value, StringComparison.Ordinal);
    while (index >= 0)
    {
        positions.Add(index);
        index = text.IndexOf(value, index + 1, StringComparison.Ordinal);
    }
    return positions;
}

using System.Buffers;

string comment = "Great post, but the SPAM filter flagged my link";
string[] banned = ["spam", "scam", "casino"];

// Does it contain ANY of them? LINQ Any + Contains
Console.WriteLine(banned.Any(word => comment.Contains(word, StringComparison.OrdinalIgnoreCase)));

// ALL of them?
string[] required = ["post", "link"];
Console.WriteLine(required.All(word => comment.Contains(word, StringComparison.Ordinal)));

// Which one matched?
string? hit = banned.FirstOrDefault(word => comment.Contains(word, StringComparison.OrdinalIgnoreCase));
Console.WriteLine(hit ?? "none");

// .NET 9+: SearchValues<string> precomputes the needles for fast repeated searches.
// Create it once (a static field in real code) and reuse it.
SearchValues<string> bannedWords = SearchValues.Create(banned, StringComparison.OrdinalIgnoreCase);
Console.WriteLine(comment.AsSpan().ContainsAny(bannedWords));
int at = comment.AsSpan().IndexOfAny(bannedWords);
Console.WriteLine($"{at}: {comment.Substring(at, 4)}");

// Any of a set of characters: IndexOfAny(char[]), or SearchValues<char> on .NET 8+
string fileName = "report:2026?.txt";
char[] invalid = ['<', '>', ':', '"', '|', '?', '*'];
Console.WriteLine(fileName.IndexOfAny(invalid));
SearchValues<char> invalidChars = SearchValues.Create("<>:\"|?*");
Console.WriteLine(fileName.AsSpan().ContainsAny(invalidChars));
Console.WriteLine("report-2026.txt".AsSpan().ContainsAny(invalidChars));

using System.Text.RegularExpressions;

string sentence = "The category is concatenated with cat_id";

// Contains matches inside words
Console.WriteLine(sentence.Contains("cat", StringComparison.OrdinalIgnoreCase));

// \b anchors the match at word boundaries: "cat" as a whole word only
Console.WriteLine(Regex.IsMatch(sentence, @"\bcat\b", RegexOptions.IgnoreCase));
Console.WriteLine(Regex.IsMatch("I have a Cat.", @"\bcat\b", RegexOptions.IgnoreCase));

// A pattern instead of a fixed string: does it contain an order number?
Match order = Regex.Match("Ref: order #A-10427 shipped", @"#[A-Z]-\d+");
Console.WriteLine(order.Success ? order.Value : "no order number");

// Regex.Escape turns user input into a literal pattern
string userInput = "1+1=2 (maybe)";
string pattern = $@"\b{Regex.Escape(userInput)}";
Console.WriteLine(pattern);
Console.WriteLine(Regex.IsMatch("says 1+1=2 (maybe) today", pattern));

// Without Escape, "+" and "(" are regex syntax and the match fails
Console.WriteLine(Regex.IsMatch("says 1+1=2 (maybe) today", userInput));

// Searching many strings with one pattern? Build the Regex once and reuse it
Console.WriteLine(Patterns.WholeWordCat.IsMatch("a cat_id is not a cat"));
Console.WriteLine(Patterns.WholeWordCat.IsMatch("concatenate"));

static class Patterns
{
    public static readonly Regex WholeWordCat =
        new(@"\bcat\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);
}