C# String CompareOrdinal() Method

What You’ll Learn

The static String.CompareOrdinal() method compares two strings using ordinal rules—it walks UTF-16 code units in order without culture or locale influence. It returns an int ideal for sorting file paths, dictionary keys, and protocol identifiers where predictable, fast comparison matters.

Definition and Usage

In C#, String.CompareOrdinal(string strA, string strB) performs a binary-style ordinal comparison. The runtime compares each UTF-16 code unit in strA against the corresponding code unit in strB from left to right until a difference appears or one string ends.

Unlike culture-aware Compare(), ordinal comparison ignores linguistic rules (such as how a specific language sorts accented letters). That makes it predictable and fast—perfect for internal identifiers, HTTP headers, file paths on case-sensitive systems, and hash-table keys where you need the same result on every machine.

📝 Syntax

Two overloads declared on System.String:

public static int CompareOrdinal(string strA, string strB);

public static int CompareOrdinal(
    string strA, int indexA,
    string strB, int indexB,
    int length);

Parameters

• strA, strB — the strings to compare (either may be null).
• indexA, indexB — starting positions for the partial overload.
• length — number of characters to compare in each string from the start index.

Return Value

< 0   →  strA is less than strB
  0   →  strA equals strB (ordinal rules)
> 0   →  strA is greater than strB

Examples Gallery

Run with dotnet run. Each example demonstrates ordinal comparison from basic ordering to case sensitivity, equivalence with StringComparison.Ordinal, and partial segment comparison.

using System;

class Program {
    static void Main() {
        string str1 = "apple";
        string str2 = "banana";

        int result = string.CompareOrdinal(str1, str2);

        Console.WriteLine($"Comparison result: {result}");

        if (result < 0) {
            Console.WriteLine("\"apple\" comes before \"banana\"");
        }
    }
}

Comparison result: -1
"apple" comes before "banana"

using System;

class Program {
    static void Main() {
        string a = "C#";
        string b = "C#";

        int result = string.CompareOrdinal(a, b);

        Console.WriteLine($"Result: {result}");
        Console.WriteLine($"Ordinally equal: {result == 0}");
    }
}

Result: 0
Ordinally equal: True

using System;

class Program {
    static void Main() {
        string upper = "Report.PDF";
        string lower = "report.pdf";

        int ordinal = string.CompareOrdinal(upper, lower);

        Console.WriteLine($"CompareOrdinal: {ordinal}");

        int ignoreCase = string.Compare(
            upper, lower, StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"OrdinalIgnoreCase: {ignoreCase}");
    }
}

CompareOrdinal: -1
OrdinalIgnoreCase: 0

using System;

class Program {
    static void Main() {
        string path1 = "apple";
        string path2 = "banana";

        int viaCompareOrdinal = string.CompareOrdinal(path1, path2);
        int viaStringComparison = string.Compare(
            path1, path2, StringComparison.Ordinal);

        Console.WriteLine($"CompareOrdinal:     {viaCompareOrdinal}");
        Console.WriteLine($"StringComparison:   {viaStringComparison}");
        Console.WriteLine($"Same sign: {Math.Sign(viaCompareOrdinal) == Math.Sign(viaStringComparison)}");
    }
}

CompareOrdinal:     -1
StringComparison:   -1
Same sign: True

using System;

class Program {
    static void Main() {
        string header1 = "GET /api/users HTTP/1.1";
        string header2 = "GET /api/orders HTTP/1.1";

        // Compare "GET " (4 chars) — should be equal
        int method = string.CompareOrdinal(
            header1, 0, header2, 0, 4);

        // Compare "/api/" prefix (5 chars starting at index 4)
        int route = string.CompareOrdinal(
            header1, 4, header2, 4, 5);

        Console.WriteLine($"Method line prefix: {method}");
        Console.WriteLine($"/api/ prefix:       {route}");
    }
}

Method line prefix: 0
/api/ prefix:       0

🚀 Common Use Cases

• File and URL paths — predictable ordering on case-sensitive systems.
• Dictionary and hash keys — fast, culture-independent key comparison.
• HTTP headers and protocol tokens — exact code-unit matching without locale rules.
• Version strings — ordinal compare works well for fixed-format identifiers (with caution for semantic versioning).
• Prefix checks — partial overload to test leading segments without Substring().

📝 Notes

• CompareOrdinal() is case-sensitive—"A" and "a" are not equal.
• It compares UTF-16 code units, not user-perceived graphemes—surrogate pairs (emoji) use two code units.
• Equivalent to string.Compare(a, b, StringComparison.Ordinal).
• For case-insensitive ordinal, use StringComparison.OrdinalIgnoreCase—there is no CompareOrdinalIgnoreCase static method.
• Use culture-aware Compare() for names and words shown to users in sorted lists.
• null is less than any non-null string; two null values compare as equal (0).

⚡ Optimization

Ordinal comparison skips culture lookup and collation tables, making it faster than culture-sensitive Compare() for most inputs. The partial overload avoids allocating temporary substrings when you only need to test a prefix or segment. For high-throughput scenarios (hash tables, sorting millions of internal keys), prefer ordinal rules unless you explicitly need locale-aware ordering.

💡 Best Practices