What is the difference between ordinal and culture-sensitive string comparison in .NET? When should you use StringComparison.Ordinal, OrdinalIgnoreCase, CurrentCulture and InvariantCulture, and which string methods default to which?

1. What ordinal comparison does

Ordinal compares the char (UTF-16 code unit) sequences numerically:

• Equality: reference check → length check → vectorised (SIMD) comparison of memory. Extremely fast.
• Ordering: compares code unit by code unit; the first difference decides. Upper-case ASCII letters (65–90) sort before lower-case (97–122), so "Zebra" < "apple".
• Surrogate pairs (emoji, rare CJK) compare by code unit, which matches code point order for most practical purposes but not perfectly across all ranges.

OrdinalIgnoreCase maps both strings using invariant simple case folding (ToUpperInvariant per char, with a fast ASCII path) and compares. It does not handle multi-character mappings like ß → SS, and it is not culture-dependent — which is exactly what you want for identifiers.

2. What culture-sensitive comparison does

Linguistic comparison uses collation: each string is converted (conceptually) into a sort key with multiple levels of weights:

1. Primary: base letters (a vs b).
2. Secondary: accents (e vs é).
3. Tertiary: case and variants (a vs A).
4. Plus rules for ignorable characters, contractions (ch in traditional Spanish), expansions (æ → ae), and canonical equivalence (é U+00E9 equals e + U+0301).

Options like CompareOptions.IgnoreCase, IgnoreNonSpace (accents), IgnoreSymbols, IgnoreKanaType, IgnoreWidth choose which levels matter. CompareInfo.GetSortKey exposes the key; string.Compare(a, b, culture, options) uses it.

On .NET 5+ (all platforms) the implementation is ICU, replacing Windows NLS. ICU and NLS differ in edge cases — the biggest migration surprise is that embedded nulls and some control characters are ignorable in ICU, so "\r\n".IndexOf("\n") with culture rules may return -1 (ICU treats \r\n as a single grapheme), and "abc\0".Equals("abc", CurrentCulture) can be true.

3. Why ordinal is the safe default for identifiers

Identifiers (keys, codes, paths, tokens) are not language — they are byte-like symbols with an exact meaning. Linguistic comparison introduces:

• Non-determinism across machines: results vary by culture and ICU version.
• False equalities: ignorable characters, canonical equivalence, accent/width options.
• Performance cost: linguistic comparison can be 10–100× slower than ordinal because it may compute collation elements.

Ordinal is deterministic, fast, and matches how databases (with binary collations), file systems on Linux, and protocols compare.

4. Interaction with databases

SQL Server comparisons depend on column collation: the default SQL_Latin1_General_CP1_CI_AS / Latin1_General_100_CI_AS is case-insensitive and accent-sensitive. EF Core translates == to SQL =, so the database decides, not .NET. A query that is case-sensitive in unit tests (in-memory provider, ordinal) can be case-insensitive in production — another reason to test against a real database (Testcontainers) and to use EF.Functions.Collate when you need a specific behaviour.

5. Normalisation

Canonically equivalent strings (é precomposed vs e + combining acute) are different under ordinal comparison. If you need equality of user-entered identifiers (usernames), normalise first (s.Normalize(NormalizationForm.FormC)) and then compare ordinally; for security-sensitive identifiers, also consider NFKC and confusable detection (Unicode TR39) to stop look-alike attacks such as Cyrillic а vs Latin a.

6. Choosing comparers in APIs

• StringComparer.Ordinal, OrdinalIgnoreCase, InvariantCulture, CurrentCulture, and StringComparer.Create(culture, CompareOptions) give IComparer<string> + IEqualityComparer<string>.
• StringComparer.FromComparison(StringComparison) maps from the enum.
• For Span-based code: MemoryExtensions.Equals(span, other, StringComparison), span.StartsWith(..., StringComparison).
• string.GetHashCode(StringComparison) provides a matching hash.

7. Performance numbers (rough)

Sorting a large list with the default culture comparer is a common hidden cost.

Try it yourself

1. Set CultureInfo.CurrentCulture = new CultureInfo("tr-TR") and compare "FILE".ToLower() == "file".
2. Compare "é" and "é" with Ordinal and InvariantCulture, then normalise and compare again.
3. Run "a\r\nb".IndexOf("\n") with and without StringComparison.Ordinal on .NET 5+.
4. Sort ["apple", "Banana", "cherry"] with StringComparer.Ordinal and with CurrentCulture.

using System.Collections.Frozen;
using System.Globalization;

namespace Strings;

public static class Comparison
{
    // Allow-list of hosts: ordinal, case-insensitive, read-only and fast
    private static readonly FrozenSet<string> AllowedHosts =
        FrozenSet.Create(StringComparer.OrdinalIgnoreCase, ["api.example.com.au", "portal.example.com.au"]);

    public static void Main()
    {
        // Identifiers: ordinal
        Console.WriteLine(string.Equals("Order-1", "order-1", StringComparison.OrdinalIgnoreCase)); // True

        // Explicit comparison on culture-sensitive-by-default APIs
        string path = "/Admin/users";
        Console.WriteLine(path.StartsWith("/admin", StringComparison.OrdinalIgnoreCase));          // True
        Console.WriteLine("\r\n".IndexOf("\n", StringComparison.Ordinal));                         // 1

        // Turkish I: ToUpper comparisons break, OrdinalIgnoreCase does not
        var turkish = CultureInfo.GetCultureInfo("tr-TR");
        Console.WriteLine("file".ToUpper(turkish) == "FILE");                                     // False
        Console.WriteLine(string.Equals("file", "FILE", StringComparison.OrdinalIgnoreCase));      // True

        // Dictionary keyed case-insensitively
        var tenants = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase) { ["Contoso"] = 1 };
        Console.WriteLine(tenants.ContainsKey("CONTOSO"));                                         // True

        // User-facing sort: culture-aware
        string[] names = ["zoe", "Émile", "adam", "Ben"];
        var auComparer = StringComparer.Create(CultureInfo.GetCultureInfo("en-AU"), ignoreCase: true);
        Console.WriteLine(string.Join(", ", names.Order(auComparer)));       // adam, Ben, Émile, zoe
        Console.WriteLine(string.Join(", ", names.Order(StringComparer.Ordinal))); // Ben, adam, zoe, Émile

        Console.WriteLine(AllowedHosts.Contains("API.example.com.au"));      // True
    }
}