.NET

Case Insensitive Comparison in C#

1 second ago
0 Comments

Performing case-insensitive string comparisons correctly in C# requires balancing correctness, linguistic context, and memory performance. Modern .NET best practices emphasize avoiding allocations caused by older idioms like str.ToLower() == str2.ToLower(), and instead using APIs that take explicit StringComparison or IEqualityComparer<string> arguments.

1. The Core Comparison Modes

In C#, case-insensitive comparison is governed by the StringComparison enum. Choosing the wrong enum value can lead to subtle bugs or security vulnerabilities:

StringComparison Option Purpose Best Used For
OrdinalIgnoreCase Compares binary code points ignoring case (invariant casing table). Fast and culture-agnostic. Internal IDs, JSON keys, URLs, headers, file paths, machine-to-machine tokens.
CurrentCultureIgnoreCase Compares using linguistic rules of the execution environment’s thread/locale. User-facing textual inputs, localized search queries, sorting UI lists.
InvariantCultureIgnoreCase Compares using linguistic conventions of the invariant culture (similar to US English). Culturally standardized text where consistency across all servers is required.

Guideline (from Microsoft Docs / Roslyn rule CA1309 / CA1862): Default to OrdinalIgnoreCase for almost all program logic, protocol parsing, and programmatic identifiers. Only use culture-aware comparisons when presenting or parsing human linguistic data.

2. Checking for Equality

Use the static string.Equals method to prevent NullReferenceException if the source variable might be null:

C#

string inputRole = "admin";
string expectedRole = "Admin";

// Recommended: Safe against null inputs and allocation-free
bool isMatch = string.Equals(inputRole, expectedRole, StringComparison.OrdinalIgnoreCase);

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

Why avoid ToLower() and ToUpper()?

C#

// ANTI-PATTERN (Violates CA1862)
if (inputRole.ToLower() == expectedRole.ToLower()) { ... }

  1. Memory Allocations: ToLower() allocates two new heap strings on every check.

  2. Linguistic Gotchas: In cultures like Turkish (tr-TR), the lowercase form of I is ı (dotless i), while i is the lowercase form of İ (dotted I). Unspecified ToLower() calls can break logic depending on the operating system locale.

3. Substrings, Prefixes, and Suffixes

Standard string inspection methods accept StringComparison overloads:

C#

string fileName = "Report_2026_FINAL.PDF";

// StartsWith
bool isReport = fileName.StartsWith("report", StringComparison.OrdinalIgnoreCase);

// EndsWith
bool isPdf = fileName.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase);

// Contains
bool containsYear = fileName.Contains("2026_final", StringComparison.OrdinalIgnoreCase);

// IndexOf
int position = fileName.IndexOf("final", StringComparison.OrdinalIgnoreCase);

4. Sorting and Ordering (string.Compare)

When comparing strings for ordering or sorting, use string.Compare with a StringComparison value:

C#

string strA = "apple";
string strB = "Banana";

// Returns:
//   < 0 if strA precedes strB
//     0 if both are equivalent
//   > 0 if strA follows strB
int result = string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase);

Console.WriteLine(result < 0 ? "A comes before B" : "A comes after B");

5. Collections, Dictionaries, and HashSets

By default, types like Dictionary<string, T> and HashSet<string> use case-sensitive ordinal comparisons. To make them case-insensitive, pass StringComparer into the constructor:

C#

// Case-insensitive lookup dictionary
var userSettings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
    ["Theme"] = "Dark",
    ["FontSize"] = "14"
};

// Both match successfully:
bool hasTheme = userSettings.ContainsKey("theme"); // True
string size = userSettings["fontsize"];            // "14"

// Case-insensitive unique set
var allowedDomains = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{
    "example.com",
    "contoso.com"
};

bool isAllowed = allowedDomains.Contains("EXAMPLE.COM"); // True

6. LINQ Queries

When filtering collections with LINQ, pass StringComparison into predicates, or pass StringComparer into set operations:

C#

var tags = new List<string> { "DotNet", "CSharp", "Azure" };

// 1. In a Where clause
var matches = tags.Where(t => t.Equals("csharp", StringComparison.OrdinalIgnoreCase));

// 2. Set operations with StringComparer
var excludeList = new[] { "dotnet" };
var filtered = tags.Except(excludeList, StringComparer.OrdinalIgnoreCase);
// Result: ["CSharp", "Azure"]

Summary of Best Practices

  1. Avoid allocations: Replace .ToLower() or .ToUpper() with StringComparison overloads.

  2. Default to OrdinalIgnoreCase: Machine-generated strings, config flags, IDs, and paths should always use ordinal comparison.

  3. Use CurrentCultureIgnoreCase for UI: Reserve culture-aware comparisons for user-facing features where locale rules (accents, regional capitalizations) matter.

  4. Pass StringComparer.OrdinalIgnoreCase to collections: Ensure case-insensitive hash lookups by setting the comparer in collection constructors.

Tags:
Shares:

Leave a Reply