C# String GetHashCode() Method

What You’ll Learn

The instance method GetHashCode() returns an int hash computed from a string’s characters. Collections like Dictionary<string, T> and HashSet<string> use it internally for fast lookups. It overrides Object.GetHashCode() with a string-specific algorithm.

Definition and Usage

In C#, every object inherits GetHashCode() from System.Object. The string type overrides it to produce a hash based on character content. Call it on any string: label.GetHashCode().

A hash code is a compact numeric fingerprint—not a copy of the string and not guaranteed unique. Hash tables use it to narrow down where to search, then call Equals() to confirm a true match. That is why equal strings must share the same hash code.

📝 Syntax

Common overloads on System.String:

public override int GetHashCode();
public int GetHashCode(StringComparison comparisonType);

Parameters

• Default overload — no parameters; uses ordinal rules for the hash.
• comparisonType — controls whether case/culture affects the hash (e.g. OrdinalIgnoreCase for case-insensitive keys).

Return Value

A 32-bit signed int hash code. The exact number may vary between .NET versions, but the same string content produces the same hash within a given runtime.

Examples Gallery

Run with dotnet run. Each example shows how GetHashCode() behaves—from basic usage to consistency, dictionaries, case rules, and the Equals contract.

using System;

class Program {
    static void Main() {
        string sampleString = "Hello, C#!";

        int hash1 = sampleString.GetHashCode();
        int hash2 = sampleString.GetHashCode();

        Console.WriteLine($"Hash code:        {hash1}");
        Console.WriteLine($"Second call same: {hash1 == hash2}");
    }
}

Hash code:        -1034815400
Second call same: True

using System;

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

        Console.WriteLine($"a.Equals(b):           {a.Equals(b)}");
        Console.WriteLine($"a.GetHashCode() == b:  {a.GetHashCode() == b.GetHashCode()}");
        Console.WriteLine($"a.Equals(c):           {a.Equals(c)}");
        Console.WriteLine($"a.GetHashCode() == c:  {a.GetHashCode() == c.GetHashCode()}");
    }
}

a.Equals(b):           True
a.GetHashCode() == b:  True
a.Equals(c):           False
a.GetHashCode() == c:  False

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Dictionary<string, int> scores = new Dictionary<string, int> {
            { "Alice", 95 },
            { "Bob",   88 }
        };

        string key = "Alice";
        Console.WriteLine($"Lookup key: {key}");
        Console.WriteLine($"Score:      {scores[key]}");
        Console.WriteLine($"(Dictionary hashed \"{key}\" internally to find this value)");
    }
}

Lookup key: Alice
Score:      95
(Dictionary hashed "Alice" internally to find this value)

using System;

class Program {
    static void Main() {
        string upper = "Admin";
        string lower = "admin";

        int defaultA = upper.GetHashCode();
        int defaultB = lower.GetHashCode();

        int ignoreA = upper.GetHashCode(StringComparison.OrdinalIgnoreCase);
        int ignoreB = lower.GetHashCode(StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"Default hashes equal:      {defaultA == defaultB}");
        Console.WriteLine($"IgnoreCase hashes equal:   {ignoreA == ignoreB}");
    }
}

Default hashes equal:      False
IgnoreCase hashes equal:   True

using System;

class Program {
    static void Main() {
        string s1 = string.Copy("test");
        string s2 = string.Copy("test");

        bool equal       = s1.Equals(s2);
        bool hashesMatch = s1.GetHashCode() == s2.GetHashCode();

        Console.WriteLine($"Separate objects, same text:");
        Console.WriteLine($"  Equals:           {equal}");
        Console.WriteLine($"  Hashes match:     {hashesMatch}");
        Console.WriteLine($"  ReferenceEquals:  {ReferenceEquals(s1, s2)}");
    }
}

Separate objects, same text:
  Equals:           True
  Hashes match:     True
  ReferenceEquals:  False

🚀 Common Use Cases

• Dictionary and HashSet keys — fast string lookup in collections.
• Deduplication — HashSet<string> uses hash codes to track unique values.
• Custom comparers — pairing hash with equality in user-defined types that contain strings.
• Debugging collections — inspect why keys might not be found (hash/equality mismatch).
• Case-insensitive maps — hash with OrdinalIgnoreCase for custom structures.

📝 Notes

• Hash codes are not guaranteed unique—collisions can occur.
• Never use hash codes alone for security (passwords, tokens)—they are not encryption.
• Equal strings must return equal hash codes (Equals/GetHashCode contract).
• Changing string content changes the hash—strings are immutable, so the hash is stable for a given instance.
• Exact hash values may differ across .NET versions; do not persist hashes long-term unless documented.
• Use the StringComparison overload when case rules should affect hashing.

⚡ Optimization

GetHashCode() is optimized for collection use. Avoid calling it repeatedly in tight loops when the string has not changed—cache the result if needed. Let Dictionary and HashSet manage hashing for you rather than building manual hash maps. For cryptographic needs, use SHA256 or similar—not GetHashCode().

💡 Best Practices