StringComparisonCompiler 1.0.0

About

StringComparisonCompiler is an optimizing compiler for string comparison. This replaces if/while comparisons, which can be performantly slow, with an dynamically compiled unrolled comparison. Case insensitive compares are exceptionally more performant.

The slow pattern:

while (inputString) {
    case "foo": ...
    case "bar": ...
    case "baz": ...
}

The code StringComparisonCompiler generates (returns matching index, or -1):

if (s.Length != 3) {
    return -1;
}

switch (s[0]) {
    case 'f': {
        return (s[1] == 'o' && s[2] == 'o')
            ? (0)
            : (-1);
        break;
    }
    case 'b': {
        switch (s[1]) {
            case 'a': {
                switch (s[2]) {
                    case 'r': {
                        return 1;
                        break;
                    }
                    case 'z': {
                        return 2;
                        break;
                    }
                }
                break;
            }
        }
        break;
    }
}
return -1;

Usage

Basic usage with array input returning found index:

var arr = new[] { "foo", "bar", "baz" };
var compiled = StringComparisonCompiler.Compile(arr);
Assert.AreEqual(0, compiled("foo"));
Assert.AreEqual(1, compiled("bar"));
Assert.AreEqual(2, compiled("baz"));
Assert.AreEqual(-1, compiled("Not found"));

CompileSpan can be called to compile a function that accepts ReadOnlySpan<char> but note that there is a performance penalty for using ReadOnlySpan<char> due non-removable index checks (theory).

Case insensitivity can be set by passing Compile a StringComparison.

Enums can also be used and returned. The System.ComponentModel.Description attribute can be used to map the enum entry to a different input.

public enum Foobar {
    Default,
    [Description("Renamed Entry")]
    Foo,
    Bar,
    Baz,
}

public void Test()
{
    var compiled = StringComparisonCompiler<Foobar>.Compile();

    Assert.AreEqual(Foobar.Default, compiled("Default"));
    Assert.AreEqual(Foobar.Foo, compiled("Renamed Entry"));
    Assert.AreEqual(Foobar.Bar, compiled("Bar"));
    Assert.AreEqual(Foobar.Baz, compiled("Baz"));

    Assert.AreEqual(Foobar.Default, compiled("Foo"));
    Assert.AreEqual(Foobar.Default, compiled("Foobar"));
    Assert.AreEqual(Foobar.Default, compiled("Not a realy entry!"));
}

Future development

Compile time code generation would be better for non-dynamic inputs such as enums, as it doesn't consume runtime CPU.

Linq Expressions sadly does not allow for "unsafe" code, which makes the performs of ReadOnlySpan<char> extremely poor, and prevents folding long single path runs in strings down to short, int, long comparisons. It's very possible even when it's not a folded path, that doing larger comparisons are better even if they don't merge paths.