Question

Let’s say I have an arbitrary list of regexes (IList<Regex> lst; for example). Is there any way to find out which one matches earlier in the string?

Of course there is the straightforward solution of trying each one on the string and seeing which match has the lowest index, but this could be inefficient on long strings.

Of course I can go back and pull the strings back out of each regex (Regex.ToString()) and concatenate them all together ("(regex1)|(regex2)|(regex3)"), but I find this to be an ugly solution, especially since it does not even indicate which regex was matched.

EDIT: Basically, is there a way to combine the already-compiled regexes without string manipulation and recompilation?

Answer 1

It’s pretty well known that executing one expression with multiple groups is usually slower than executing each expression in turn. It might look like creating one expression would be faster, but actually the Regex Engine will first search the whole string to find the first expression, maybe going all the way to the end of the string, but when it finds a match it will return. So there is no way to force it to return the first Match. This is due to the way the .NET Regex engine works.

Since each regex might start earlier in the string, but can potentially result in a longer match, you can’t limit the end of your search to the index of the currently earliest match like this:

        // WARNING WILL NOT ALWAYS RESULT IN THE RIGHT VALUES
        List<Regex> rxs = new List<Regex>(4);
        rxs.Add(new Regex("def"));
        rxs.Add(new Regex("abc"));
        rxs.Add(new Regex("bcd"));
        rxs.Add(new Regex("cde"));

        string target = "abcdef";
        int firstIndex = target.Length;
        string firstMatch = string.Empty;

        foreach (var rx in rxs)
        {
            var match = rx.Match(target, 0, firstIndex);
            if (match.Success)
            {
                firstIndex = match.Index;
                firstMatch = match.Value;
                if (firstIndex == 0) break;
            }
        }
        return firstMatch;

This will work when you know the maximum length each regex will match, in that case use:

        // WARNING WILL NOT ALWAYS RESULT IN THE RIGHT VALUES
        List<Regex> rxs = new List<Regex>(4);
        rxs.Add(new Regex("def"));
        rxs.Add(new Regex("abc"));
        rxs.Add(new Regex("bcd"));
        rxs.Add(new Regex("cde"));

        string target = "abcdef";
        int firstIndex = target.Length;
        string firstMatch = string.Empty;

        foreach (var rx in rxs)
        {
            var match = rx.Match(target, 0, firstIndex + GetMaxLength(rx));
            if (match.Success)
            {
                firstIndex = match.Index;
                firstMatch = match.Value;
                if (firstIndex == 0) break;
            }
        }
        return firstMatch;

But you can shortcircuit as soon as you find a match on the first position, saving you any potential executions after that.

        foreach (var rx in rxs)
        {
            var match = rx.Match(target);
            if (match.Success)
            {
                if (match.Index < firstIndex)
                {
                    firstIndex = match.Index;
                    firstMatch = match.Value;    
                }
                if (firstIndex == 0) break;
            }
        }

With a little trickery you can use the index of your current first match candidate to limit the search, but I suspect it will actually still be slower than searching all possible matches:

        List<string> rxs = new List<string>(4);
        rxs.Add( "def");
        rxs.Add( "abc");
        rxs.Add( "bcd");
        rxs.Add( "cde");

        string target = "abcdef";
        int firstIndex = target.Length;
        string firstMatch = string.Empty;

        foreach (var rx in rxs)
        {
            var match = Regex.Match(target, @"(?<!\A[\w\W]{" + firstIndex + "})" + rx);
            if (match.Success)
            {
                if (match.Index < firstIndex)
                {
                    firstIndex = match.Index;
                    firstMatch = match.Value;    
                }
                if (firstIndex == 0) break;
            }
        }

In the end, experiment and measure to find the way that works best for you.

---

I do have some extra information: At least one of the Regexes will be found near the beginning of the string.

In that case you can opt to first scan using a reasonable value for the length index, so use rx.Match(targetstring, 0, 1024 /* First scan */) and only if you don’t find a match, widen your search in a second pass. If your target string can be really large this will save a lot of compute power.