TheDeveloperBlog.com


C# Regex Versus Loop

Regex vs. loop. Regular expressions can be re-implemented with loops. For example, a loop can make sure that a string only contains a certain range of characters. Using Regex is less clear and far slower in runtime performance.


Example. First, the goal of this program is to validate the string parameter. The string must only contain the characters "a" through "z" lowercase and uppercase, and the ten digits "0" through "9".

Tip: This is of practical use on some websites and programs that parse data that may not be well-formed.

Note: IsValid1 makes sure these characters are the only ones that occur by using Regex, while IsValid2 does the same with a loop.

C# program that validates strings

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
	Console.WriteLine(IsValid1("dotnetperls100")); // Valid: has only a-z and 0-9
	Console.WriteLine(IsValid2("dotnetperls100"));
	Console.WriteLine(IsValid1("$Invalid"));       // Invalid: has $
	Console.WriteLine(IsValid2("$Invalid"));
	Console.WriteLine(IsValid1("900DOTNETPERLS")); // Valid: has only A-Z and 0-9
	Console.WriteLine(IsValid2("900DOTNETPERLS"));
	Console.WriteLine(IsValid1(" space "));        // Invalid: has space
	Console.WriteLine(IsValid2(" space "));
    }

    /// <summary>
    /// Test if string contains any of the specified characters.
    /// </summary>
    public static bool IsValid1(string path)
    {
	return Regex.IsMatch(path, @"^[a-zA-Z0-9]*$");
    }

    /// <summary>
    /// Test if string contains any of the specified characters (fast).
    /// </summary>
    public static bool IsValid2(string path)
    {
	for (int i = 0; i < path.Length; i++)
	{
	    switch (path[i])
	    {
		case 'a': // Lowercase
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':
		case 'A': // Uppercase
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case '0': // Numbers
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		    {
			continue;
		    }
		default:
		    {
			return false; // Illegal
		    }
	    }
	}
	return true; // Legal
    }
}

Output

True
True
False
False
True
True
False
False

The Program class encloses the Main entry point, which tests the IsValid1 and IsValid2 methods. The pairs of method invocations return the same Boolean value and prove that the methods operate the same on these string literals.

Tip: The two methods IsValid1 and IsValid2 have very different implementations but their results are the same.

IsValid1: This method uses Regex.IsMatch to tell whether the string only has the range of characters specified.

IsValid2 uses a for-loop to iterate through the character indexes in the string. It employs a switch statement on the char, with a collection of constant cases. The switch is compiled into a jump table. This avoids conditional branches.

For

Benchmark. We measure the two methods shown in the program text. The first two strings in the example are tested in tight loops. The final result indicates the number of nanoseconds that the method invocations required.

Results: IsValid1 (with Regex.IsMatch) required about 906 nanoseconds. IsValid2 (with switch) required about 13 nanoseconds.

So: The regular expression version required almost 70 times more processing time.

Benchmark description

1000000 loops with 2 method calls in each iteration.
Numbers reported in nanoseconds per method call.

Code tested in loops

if (IsValid1("dotnetperls100")) // Body 1 start
{
}
if (IsValid1("$Invalid"))
{
}

if (IsValid2("dotnetperls100")) // Body 2 start
{
}
if (IsValid2("$Invalid"))
{
}

Benchmark results

IsValid1: 906.665 ns     (Uses regular expression)
IsValid2:  13.500 ns     (Uses switch, faster)


Regex.IsMatch. The Regex.IsMatch method performs the logic of the Regex.Match internally, but narrows the result information to a Boolean value. This indicates whether any matching text was found or not.

Note: The Regex.IsMatch method is commonly used in if-statements to see if the string contains the pattern specified.

Regex.Match

Summary. You can test the validity of string input against a set of characters. We used the Regex.IsMatch method to check against a range of characters. We used the switch statement on an iterative loop for better performance.

Also: We noted some problems and enhancements. Short code can require much longer periods of time to execute.