Case-Insensitive String Containment in C#

Determining if a string contains another string is a common task in programming. However, often you’ll want to perform this check without regard to case – meaning "Hello" should be considered contained within "hello" or "HeLlO". While C#’s built-in Contains() method is straightforward, it’s case-sensitive. This tutorial explains how to perform case-insensitive string containment effectively and correctly.

The Challenge of Case Sensitivity

By default, C# string comparisons are case-sensitive. This means that 'hello'.Contains('Hello') will return false. To overcome this limitation, you need to employ techniques that ignore case during the comparison. Simply converting both strings to uppercase or lowercase can work, but it’s not always ideal due to potential issues with internationalization (i18n), where case transformations can behave differently depending on the culture.

Using `StringComparison` with `IndexOf()`

The most flexible and recommended approach is to utilize the String.IndexOf() method in conjunction with the StringComparison enumeration. StringComparison allows you to specify the rules for the string comparison, including case-insensitive options.

Here’s how it works:

string title = "STRING";
string searchString = "string";

bool contains = title.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0;

Console.WriteLine(contains); // Output: True

In this example:

title.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) searches for searchString within title, ignoring case.
StringComparison.OrdinalIgnoreCase specifies an ordinal comparison (efficient for performance) that ignores case.
The result of IndexOf() is the starting index of the matched substring (if found) or -1 (if not found). The check >= 0 determines if the substring was found.

Extending String with a Helper Method:

To make this more convenient, you can create an extension method for the string class:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source?.IndexOf(toCheck, comp) >= 0;
    }
}

Now you can use it like this:

string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);
Console.WriteLine(contains); // Output: True

The ?. (null-conditional operator) handles cases where the source string might be null, preventing a NullReferenceException.

Choosing the Right StringComparison Value

Several StringComparison values are available. Here’s a breakdown of some common options:

OrdinalIgnoreCase: The fastest option. Performs a simple byte-by-byte comparison, ignoring case. Suitable for most cases where cultural considerations aren’t paramount.
CurrentCultureIgnoreCase: Uses the rules of the current culture to determine case-insensitivity. This can be more accurate for specific languages but is potentially slower than OrdinalIgnoreCase.
InvariantCultureIgnoreCase: Uses the rules of the invariant culture (a culture-neutral culture) to determine case-insensitivity. This provides consistent behavior across different systems but may not be appropriate for all languages.

Considering Culture-Specific Comparisons

For applications that need to handle multiple languages correctly, you must consider culture-specific case-insensitivity rules. Different languages have different rules for determining whether two characters are considered equal when ignoring case.

using System.Globalization;

string paragraph = "This is a Test";
string word = "test";
CultureInfo culture = CultureInfo.CurrentCulture; // Or a specific culture

bool contains = CultureInfo.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;

Console.WriteLine(contains); // Output: True

Here, CultureInfo.CompareInfo provides access to the culture-specific comparison rules. CompareOptions.IgnoreCase specifies that the comparison should ignore case.

Modern .NET Options (.NET Core 2.0+)

Newer versions of .NET (Core 2.0 and later) provide a more direct approach:

string text = "Test";
bool contains = text.Contains("test", StringComparison.CurrentCultureIgnoreCase);

Console.WriteLine(contains); // Output: True

This simplifies the code and makes it more readable.

Using Regular Expressions (Regex)

While generally less efficient for simple containment checks, regular expressions can offer more complex matching capabilities.

using System.Text.RegularExpressions;

string text = "StRiNG to search";
string pattern = "string";

bool contains = Regex.IsMatch(text, Regex.Escape(pattern), RegexOptions.IgnoreCase);

Console.WriteLine(contains); // Output: True

Regex.Escape(pattern) escapes any special characters in the pattern, preventing them from being interpreted as regex metacharacters.
RegexOptions.IgnoreCase specifies that the regex match should ignore case.