C# String Equals() Method

What You’ll Learn

The Equals() method checks whether two strings contain the same characters in the same order. It returns true or false—the foundation of password checks, name matching, configuration validation, and any logic that asks “are these two texts the same?”

Definition and Usage

In C#, Equals() compares two strings for content equality. You can call it as an instance method—first.Equals(second)—or as a static method—string.Equals(first, second)—which is especially useful when either value might be null.

Unlike Compare(), which returns a sort order as an integer, Equals() answers a simple yes/no question. Unlike Contains() or EndsWith(), it compares the entire string, not just a portion.

📝 Syntax

Common overloads on System.String:

public bool Equals(string value);
public bool Equals(string value, StringComparison comparisonType);
public static bool Equals(string a, string b);
public static bool Equals(string a, string b, StringComparison comparisonType);

Parameters

• value / a, b — the string(s) to compare. Static overloads handle null safely.
• comparisonType — rules for comparison: e.g. Ordinal, OrdinalIgnoreCase, CurrentCultureIgnoreCase.

Return Value

true if both strings have identical character content under the chosen rules; false otherwise.

Examples Gallery

Run with dotnet run. Each example shows a practical way to compare strings—from basic equality to case rules, null safety, and comparison with related methods.

using System;

class Program {
    static void Main() {
        string firstString  = "Hello, C#!";
        string secondString = "Hello, C#!";
        string thirdString  = "Greetings!";

        bool equal12 = firstString.Equals(secondString);
        bool equal13 = firstString.Equals(thirdString);

        Console.WriteLine($"first == second? {equal12}");
        Console.WriteLine($"first == third?  {equal13}");
    }
}

first == second? True
first == third?  False

using System;

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

        Console.WriteLine($"Default Equals: {a.Equals(b)}");
        Console.WriteLine($"== operator:    {a == b}");
    }
}

Default Equals: False
== operator:    False

using System;

class Program {
    static void Main() {
        string input    = "Admin";
        string expected = "admin";

        bool caseSensitive = input.Equals(expected);
        bool ignoreCase    = input.Equals(
            expected,
            StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"Case-sensitive: {caseSensitive}");
        Console.WriteLine($"Ignore case:    {ignoreCase}");
    }
}

Case-sensitive: False
Ignore case:    True

using System;

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

        Console.WriteLine($"null vs null:  {string.Equals(a, b)}");
        Console.WriteLine($"null vs hello: {string.Equals(a, c)}");
        Console.WriteLine($"hello vs null: {string.Equals(c, a)}");

        // a.Equals(c) would throw NullReferenceException here
    }
}

null vs null:  True
null vs hello: False
hello vs null: False

using System;

class Program {
    static void Main() {
        string x = "apple";
        string y = "banana";

        bool areEqual = string.Equals(x, y);
        int  order    = string.Compare(x, y, StringComparison.Ordinal);

        Console.WriteLine($"Equals(x, y):  {areEqual}");
        Console.WriteLine($"Compare(x, y):   {order}");
        Console.WriteLine($"(negative = x before y)");
    }
}

Equals(x, y):  False
Compare(x, y):   -1
(negative = x before y)

🚀 Common Use Cases

• Password or token verification — compare user input to a stored value.
• Configuration keys — match setting names or enum-like string values.
• Command parsing — check if input equals "quit" or "exit".
• Unit test assertions — verify expected vs actual string output.
• Null-safe API validation — use static string.Equals on optional parameters.

📝 Notes

• Default Equals(string) is ordinal and case-sensitive.
• For strings, == compares content the same way as instance Equals.
• Calling Equals on a null instance throws NullReferenceException.
• Static string.Equals(a, b) is the safe choice when either value may be null.
• Equals compares the full string—not prefix/suffix only.
• Use StringComparison overloads instead of ToLower() for case-insensitive equality.

⚡ Optimization

Equals() and == for strings are both highly optimized in the .NET runtime—there is no meaningful performance reason to pick one over the other for equality checks. Choose based on readability and null safety. Avoid calling ToLower() on both strings before comparing; the StringComparison overload avoids extra allocations.

💡 Best Practices