C# String Compare() Method

What You’ll Learn

The static String.Compare() method compares two strings and tells you which comes first in sort order. It returns an int—not a bool—making it ideal for sorting names, validating order, and building comparison logic with optional case and culture rules.

Definition and Usage

In C#, String.Compare(string strA, string strB) is a static method that evaluates two strings character by character and reports their relative lexicographic order—the same ordering a dictionary or phone book uses.

The return value is an int: a negative number when strA comes before strB, zero when they compare as equal under the chosen rules, and a positive number when strA comes after strB. This three-way result is what sorting algorithms and Array.Sort expect.

📝 Syntax

Common overloads declared on System.String:

public static int Compare(string strA, string strB);
public static int Compare(string strA, string strB, bool ignoreCase);
public static int Compare(string strA, string strB, StringComparison comparisonType);

Parameters

• strA, strB — the two strings to compare (either may be null; null sorts before non-null).
• ignoreCase — when true, letter case is ignored using culture-sensitive rules.
• comparisonType — a StringComparison value such as Ordinal, OrdinalIgnoreCase, or CurrentCultureIgnoreCase.

Return Value

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

Examples Gallery

Run with dotnet run. Each example builds practical comparison skills from basic ordering to sorting and modern StringComparison usage.

using System;

class Program {
    static void Main() {
        int result = string.Compare("apple", "banana");

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

        if (result < 0) {
            Console.WriteLine("\"apple\" comes before \"banana\"");
        } else if (result > 0) {
            Console.WriteLine("\"apple\" comes after \"banana\"");
        } else {
            Console.WriteLine("Strings are equal");
        }
    }
}

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

using System;

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

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

        Console.WriteLine($"Result: {result}");
        Console.WriteLine($"Equal: {result == 0}");
        Console.WriteLine($"Same as == : {a == b}");
    }
}

Result: 0
Equal: True
Same as == : True

using System;

class Program {
    static void Main() {
        string a = "Hello";
        string b = "hello";

        int sensitive   = string.Compare(a, b);
        int insensitive = string.Compare(a, b, ignoreCase: true);

        Console.WriteLine($"Case-sensitive:   {sensitive}");
        Console.WriteLine($"Case-insensitive: {insensitive}");
    }
}

Case-sensitive:   -1
Case-insensitive: 0

using System;

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

        int ordinal = string.Compare(
            path1, path2, StringComparison.Ordinal);

        int ignoreCase = string.Compare(
            path1, path2, StringComparison.OrdinalIgnoreCase);

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

Ordinal:            -1
OrdinalIgnoreCase:  0

using System;

class Program {
    static void Main() {
        string[] names = { "Charlie", "alice", "Bob" };

        Array.Sort(names, StringComparer.OrdinalIgnoreCase);

        Console.WriteLine("Sorted names:");
        foreach (string name in names) {
            Console.WriteLine($"  {name}");
        }
    }
}

Sorted names:
  alice
  Bob
  Charlie

🚀 Common Use Cases

• Sorting lists — order user names, product titles, or file names alphabetically.
• Range checks — verify a value falls between two string bounds (e.g., date strings in yyyy-MM-dd format).
• Custom comparers — implement IComparer<string> using Compare() for collections.
• Case-insensitive lookup keys — match dictionary keys or HTTP headers without caring about case.
• Branching logic — choose actions based on whether one string precedes another in order.

📝 Notes

• Compare() returns int, not bool—check == 0 for equality.
• The default overload is culture-sensitive—sort order can vary by locale.
• Prefer StringComparison.Ordinal or OrdinalIgnoreCase for internal keys, paths, and identifiers.
• null is treated as less than any non-null string; two null values compare as equal (0).
• For instance-style comparison, use strA.CompareTo(strB)—same sign convention.
• When you only need equality, string.Equals(a, b, comparison) or a == b reads more clearly.

⚡ Optimization

StringComparison.Ordinal comparisons are faster than culture-sensitive comparisons because they skip locale-specific rules. For high-volume sorting or hashing of internal strings, prefer ordinal modes. Avoid calling Compare() repeatedly on the same pair inside tight loops—cache the result or pre-sort once. For large collections, use built-in Array.Sort or LINQ OrderBy with an appropriate StringComparer rather than hand-written bubble sorts.

💡 Best Practices