Type checking with strings in C#

A developer made a plugin architecture in which some plugins were built in the same library as the microkernel / core in order to provide a default implementation. Cool! The weird thing is that type checking was still being done using a public member called "Type". Here is an example of the implementation:

class BaseType
{
	public virtual string Type { get => "BaseType"; }
}
class SomeType : BaseType
{
	public override string Type => "SomeType";
}
class SomeOtherType : BaseType
{
	public override string Type => "SomeOtherType";
}

Yes, that works, but isn't it slower than using the object oriented features of the language and the optimization of the compiler? I think so, but let's see. To do this, we'll have to test string comparisons against type checking.

For type checking, we'll use the is operator.
Let's try a few approaches to string equality that will demonstrate the differences:

/// <summary>
/// Runs a test given a number of items
/// </summary>
/// <param name="numberOfItems">The number of items</param>
public static Dictionary<string, long> Run(int numberOfItems)
{
	var ret = new Dictionary<string, long>();

	IEnumerable<BaseType> collection = Enumerable.Range(1, numberOfItems)
		.Select(i => i % 2 == 0 ? new SomeType() as BaseType : new SomeOtherType())
		.ToArray();

	var current = new BaseType();

	foreach (var act in new Action[]
	{
		() => {
			var sw = System.Diagnostics.Stopwatch.StartNew();
			foreach (var item in collection)
			{
				if (item.Type == "SomeType")
				{
					current = item;
				}
			}
			sw.Stop();
			ret.Add("String ==", sw.Elapsed.Ticks);
		},
		() => {
			var sw = System.Diagnostics.Stopwatch.StartNew();
			foreach (var item in collection)
			{
				if (item.Type.Equals("SomeType"))
				{
					current = item;
				}
			}
			sw.Stop();
			ret.Add("String Equals", sw.Elapsed.Ticks);
		},
		() => {
			var sw = System.Diagnostics.Stopwatch.StartNew();
			foreach (var item in collection)
			{
				if (item.Type.Equals("SomeType", StringComparison.InvariantCultureIgnoreCase))
				{
					current = item;
				}
			}
			sw.Stop();
			ret.Add("String Equals Invariant", sw.Elapsed.Ticks);
		},
		() => {
			var sw = System.Diagnostics.Stopwatch.StartNew();
			foreach (var item in collection)
			{
				if (item is SomeType)
				{
					current = item;
				}
			}
			sw.Stop();
			ret.Add("is Type Check", sw.Elapsed.Ticks);
		}
	}.Shuffle()) { act.RunWithNoGarbageCollection(); };           


	return ret;
}

Here is the average of 30 runs, run in random orders (all times in Ticks):

Average Time (in ticks) to access N number of items

Let's normalize to a single approach: Type checking.

Normalized Average Time (with respect to is Type Check)

Visually, this might make more sense on a log2 - log2 plot...

These results are really interesting. First we see that type checking is the fastest (yay, I was right!). There has to be some compiler optimizer helping with that. Next we see that == is the fastest comparison. While Equals is a little slower, Equals Invariant is more than 2x slower than that.

Why are some comparisons faster than others? Let's look at the source code...

First we look at the equals operator (==).

public static bool operator ==(string? a, string? b)
{
	if ((object)a == b)
	{
		return true;
	}
	if ((object)a == null || (object)b == null || a!.Length != b!.Length)
	{
		return false;
	}
	return EqualsHelper(a, b);
}

Not too bad. But it's good to know that EqualsHelper goes through every character and compares its numeric value.

Now check the Equals method by itself. That's fairly straight-forward.

public bool Equals(string? value)
{
	if ((object)this == value)
	{
		return true;
	}
	if ((object)value == null)
	{
		return false;
	}
	if (Length != value!.Length)
	{
		return false;
	}
	return EqualsHelper(this, value);
}

Now check the Equals operator with Comparison type (for Equals Invariant).

public bool Equals(string? value, StringComparison comparisonType)
{
	if ((object)this == value)
	{
		CheckStringComparison(comparisonType);
		return true;
	}
	if ((object)value == null)
	{
		CheckStringComparison(comparisonType);
		return false;
	}
	switch (comparisonType)
	{
	case StringComparison.CurrentCulture:
	case StringComparison.CurrentCultureIgnoreCase:
		return CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
	case StringComparison.InvariantCulture:
	case StringComparison.InvariantCultureIgnoreCase:
		return CompareInfo.Invariant.Compare(this, value, GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
	case StringComparison.Ordinal:
		if (Length != value!.Length)
		{
			return false;
		}
		return EqualsHelper(this, value);
	case StringComparison.OrdinalIgnoreCase:
		if (Length != value!.Length)
		{
			return false;
		}
		return EqualsOrdinalIgnoreCase(this, value);
	default:
		throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
	}
}

Does this difference explain the 16x difference in speed? Somewhat. == and Equals are nearly the same but == is faster. I guess this is one of those many cases where static methods are faster than instance methods.