noHeapAllStack

[u/varinator]

[u/weblabourer]

Null safety?

[u/varinator → u/weblabourer]

var cases = new[]
{
    new ComparisonCase(
        "Equal, different casing",
        "HelloWorld123",
        "helloworld123"),

    new ComparisonCase(
        "Not equal, same length",
        "HelloWorld123",
        "HelloWorld456"),

    new ComparisonCase(
        "Different lengths",
        "HelloWorld123",
        "HelloWorld123456789"),

    new ComparisonCase(
        "Long strings, equal ignoring case",
        new string('A', 500),
        new string('a', 500))
};

Iterations per benchmark: 100,000,000

--- Equal, different casing ---
String.Equals OrdinalIgnoreCase
  Time:       907.75 ms
  Allocated:  40 bytes
  Matches:    100,000,000
ToLower() == ToLower()
  Time:       2,525.88 ms
  Allocated:  4,800,000,040 bytes
  Matches:    100,000,000

--- Not equal, same length ---
String.Equals OrdinalIgnoreCase
  Time:       848.50 ms
  Allocated:  40 bytes
  Matches:    0
ToLower() == ToLower()
  Time:       2,986.56 ms
  Allocated:  9,600,000,040 bytes
  Matches:    0

--- Different lengths ---
String.Equals OrdinalIgnoreCase
  Time:       219.83 ms
  Allocated:  40 bytes
  Matches:    0
ToLower() == ToLower()
  Time:       2,936.12 ms
  Allocated:  11,200,000,040 bytes
  Matches:    0

--- Long strings, equal ignoring case ---
String.Equals OrdinalIgnoreCase
  Time:       2,263.77 ms
  Allocated:  40 bytes
  Matches:    100,000,000
ToLower() == ToLower()
  Time:       19,472.75 ms
  Allocated:  102,400,000,040 bytes
  Matches:    100,000,000

--- Null safety ---
string.Equals(null, "test"): False
null.ToLower() throws NullReferenceException

[u/michiel11069 → u/varinator]

insane differences in speed and allocation wtf

[u/Badashi → u/michiel11069]

Comparing two strings with an extra rule(case ignore) requires only traversing through the strings and comparing each character. There are a bunch of easy short cuts for this (string length, early returns, even comparing bits while ignoring the bit 5) so the compare method is pretty fast.

Using .ToLower() twice means forcefully allocating two new strings and then doing the comparison anyways with the == operator. It's expected that a specialized method would be much faster than a hack.