String Comparison Optimization in C#

Like carbon, hydrogen, oxygen, and nitrogen in the table of elements, strings are a fundamental building block in software development. It is rare to write a program of a given size without the need to compare strings of one form or another. However, despite their deceptive simplicity, strings can exact a toll on a program's performance if not handled carefully. In this blog, I will be looking at three of the most common use cases and the associated impact impact implications of each approach.

Culture-Sensitive Comparisons

stringA.CompareTo(stringB)

Microsoft introduced this method to help with sorting or filtering alphabetic comparisons.

Despite the difference, developers often (mis)use the CompareTo method for determining whether or not two strings are equivalent. It should not be used in this case. If A to B comparisons are your use case, call the Equals method as described below.

Ordinal Comparisons

stringA.Equals(stringB)

Equality Operator Comparisons

stringA == stringB

The == operator calls the static Equals(string a, string b) method, which in turn goes to an internal EqualsHelper to do the comparison. The reason for this, in large part, is that strings are immutable. In other words, you cannot modify an existing string that has been allocated a position in memory. String functions, such as myString.Concat(), create a new temporary string, leaving the CLR to manage garbage collection. This process requires more memory and clock cycles. Left unchecked, the impact on performance can be significant.

In an effort to write efficient code while avoiding some of the performance risks of string handling, there are some things to keep in mind during development.

ReferenceEquals Comparisons

Object.ReferenceEquals(stringA, stringB)

Object.ReferenceEquals always returns false for value types and you should not use ReferenceEquals to determine string equality.

Performance Benchmarks of Comparison Types

void PrintMatches(string[] partList, string[] otherPartList)
{

   for (int i = 0; i < partList.Length; i++)
   {

     for (int j = 0; j < otherPartList.length; j++)
     {
       if (partList[i].Equals(otherPartList[j]))
       { 
          Console.WriteLine(partList[i]);
       }
     }
 }

After digging a bit and running some tests, I offered that the below method will offer a performance improvement:

static void PrintMatches(string[] partList, string[] otherPartList)
{

      for (int i = 0; i < partList.Length; i++)
      {
           for (int j = 0; j < otherPartList.Length; j++)
           {
                if (String.Equals(partList[i], otherPartList[j]))
                {
                    Console.WriteLine(partList[i]);
                }
           }
      }
}

The reason for the improvement is that there is a small but significant difference between the static method String.Equals ( a, b ) and the instance method a.Equals ( b ). In the case of the former, the performance hike we see is because .NET does an object reference comparison before it looks at the string.  

if ((object)a == (object)b)
{
    return true;
}

Conversely, the instance method skips this step and begins string comparisons straight away.
To illustrate this difference, I lined up and ran both the Instance Equals and the Static Equals against a static dataset that found 6879 matches. 

 
Using TimeSpan ts = stopWatch.Elapsed as a measure of time, 1000 runs of each of the below Equals implementations produced the below results. 

 

Equals Implementation	Total Runs	Arithmetic Mean
PrintStaticMatches	1000	79178 t
PrintInstanceMatches	1000	82103 t

Conclusion

Lining up string comparison functions next to each other is not apples to apples. They are notable differences between them. Those differences can, over time, impact program performance if gone unchecked. Compare strings mindfully by stopping and asking yourself some questions first. Are you comparing value types or reference types? Is your implementation of an instance or static method comparison appropriate for the scenario? With some of these small but notable adjustments, the overall performance of your application is will improve measurably. 

Attachments:
Random Words A: Random Words A
Random Words B: Random Words B