C# String CompareTo() Method

What You’ll Learn

The instance method CompareTo() compares the calling string to another and returns an int describing their lexicographic order. It implements IComparable<string>, which makes it the default comparison used when you sort lists and arrays of strings.

Definition and Usage

In C#, CompareTo(string value) is called on an existing string and compares it to value. The method walks both strings character by character using culture-sensitive rules and returns a signed integer describing which string comes first.

Unlike the static String.Compare() method, CompareTo() is an instance method—you write first.CompareTo(second), not String.CompareTo(first, second). Because String implements IComparable<string>, collections like List<string>.Sort() use CompareTo() automatically.

📝 Syntax

Two related signatures on System.String:

public int CompareTo(string value);

public int CompareTo(object value);  // IComparable implementation

Parameters

• value — the string to compare against the current instance. May be null.

Return Value

< 0   →  this string is less than value
  0   →  this string equals value
> 0   →  this string is greater than value

Examples Gallery

Run with dotnet run. Each example builds practical skills from basic ordering to sorting, null handling, and comparison with the static Compare() method.

using System;

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

        int result = str1.CompareTo(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 = a.CompareTo(b);

        Console.WriteLine($"CompareTo result: {result}");
        Console.WriteLine($"Equals via == : {a == b}");
    }
}

CompareTo result: 0
Equals via == : True

using System;

class Program {
    static void Main() {
        string upper = "Hello";
        string lower = "hello";

        int compareToResult = upper.CompareTo(lower);
        int staticIgnoreCase = string.Compare(
            upper, lower, StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"CompareTo (case-sensitive):   {compareToResult}");
        Console.WriteLine($"Compare (OrdinalIgnoreCase):  {staticIgnoreCase}");
    }
}

CompareTo (case-sensitive):   -1
Compare (OrdinalIgnoreCase):  0

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> {
            "Charlie", "alice", "Bob"
        };

        names.Sort();

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

Sorted (default CompareTo):
  Charlie
  alice
  Bob

using System;

class Program {
    static void Main() {
        string text = "Hello";

        int vsNull = text.CompareTo(null);

        Console.WriteLine($"\"Hello\".CompareTo(null): {vsNull}");
        Console.WriteLine("(Calling CompareTo on a null string throws NullReferenceException)");
    }
}

"Hello".CompareTo(null): 1
(Calling CompareTo on a null string throws NullReferenceException)

🚀 Common Use Cases

• Sorting collections — default Sort() on lists and arrays of strings.
• Ordered collections — SortedSet<string> and SortedDictionary rely on comparison semantics.
• Range validation — check whether a name falls between two bounds alphabetically.
• Custom comparers — understand default behavior before wrapping with StringComparer.
• IComparable patterns — mirror CompareTo when implementing your own comparable types.

📝 Notes

• CompareTo() returns int, not bool—check signs explicitly.
• Comparison is case-sensitive by default—"a" and "A" differ.
• Uses current culture rules—sort order may vary by locale.
• text.CompareTo(null) returns positive; null.CompareTo(...) throws.
• Equivalent to string.Compare(this, value) for the string overload.
• For ordinal or explicit culture rules, prefer string.Compare with StringComparison.

⚡ Optimization

CompareTo() is efficient for typical string lengths. Avoid calling ToUpper() or ToLower() on every comparison in a sort loop—that allocates new strings repeatedly. Instead, pass StringComparer.OrdinalIgnoreCase to List.Sort(comparer) or use string.Compare with the appropriate StringComparison value once per comparison.

💡 Best Practices