RegEx.IsMatch() vs. String.ToUpper().Contains() performance

c#, regex, string

Solution

Here's a benchmark

using System;
using System.Diagnostics;
using System.Text.RegularExpressions;

public class Program
{
    public static void Main(string[] args)
    {
        Stopwatch sw = new Stopwatch();

        string testString = "tHiSISaSTRINGwiThInconSISteNTcaPITaLIZATion";

        sw.Start();
        var re = new Regex("string", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
        for (int i = 0; i < 1000000; i++)
        {
            bool containsString = re.IsMatch(testString);
        }
        sw.Stop();
        Console.WriteLine("RX: " + sw.ElapsedMilliseconds);

        sw.Restart();
        for (int i = 0; i < 1000000; i++)
        {
            bool containsStringRegEx = testString.ToUpper().Contains("STRING");
        }


        sw.Stop();
        Console.WriteLine("Contains: " + sw.ElapsedMilliseconds);

        sw.Restart();
        for (int i = 0; i < 1000000; i++)
        {
            bool containsStringRegEx = testString.IndexOf("STRING", StringComparison.OrdinalIgnoreCase) >= 0 ;
        }


        sw.Stop();
        Console.WriteLine("IndexOf: " + sw.ElapsedMilliseconds);
    }
}

Results were

IndexOf (183ms) > Contains (400ms) > Regex (477ms)

(Updated output times using the compiled Regex)

Problem

Since there is no case insensitive `string.Contains()` (yet a case insensitive version of `string.Equals()` exists which baffles me, but I digress) in .NET, What is the performance differences between using `RegEx.IsMatch()` vs. using `String.ToUpper().Contains()`? Example: ``` string testString = "tHiSISaSTRINGwiThInconSISteNTcaPITaLIZATion"; bool containsString = RegEx.IsMatch(testString, "string", RegexOptions.IgnoreCase); bool containsStringRegEx = testString.ToUpper().Contains("STRING"); ``` I've always heard that `string.ToUpper()` is a very expensive call so I shy away from using it when I want to do `string.Contains()` comparisons, but how does `RegEx.IsMatch()` compare in terms of performance? Is there a more efficient approach for doing such comparisons?

Original source

Related problems