Is there a reason to do a type comparison this way?

Question

I'm used to seeing old code like

if (true)
{
    ...
}

where it's intuitively clear that someone was being either lazy or overly cautious when making a change. I ran across this snippet today, and I'm curious whether there's a functional difference between doing type comparison this way:

private static bool logField(Type t, string fieldname)
{
    if (t.ToString() == typeof (Property).ToString())
    {
        ...
    }
    return true;
}

and doing it this way:

private static bool logField(Type t, string fieldname)
{
    if (t == typeof (Property))
    {
        ...
    }
    return true;
}

Answer 1

I can't think of any good reasons.

In fact, the former will throw if t is null.

Answer 2

I'd say that's generally laziness - but it may not be. For example, you could have two Property types, in the same effective file, but different copies. If typeof(Property) loads it from one file but t is loaded from a different one, your replacement would say they were different but the original code would compare say they were the same.

It's definitely an edge case, and one that you normally want to avoid in the first place... but it's just possible.

Answer 3

No, getting the type object of 2 instances of the same type will always return a reference to the same type object in memory. This means that performing a reference equality check (==) is sufficient.

Essentially, calling: if (t.ToString() == typeof (Property).ToString())

will call ToString() twice on the same object, where t is the 'Property' type.

Answer 4

The first one compares references of Strings, while the second one actually checks to see if t is of the Property type.

The first one will always be "correct" because the two strings refer to the same object, but the second one is the correct way to check if t is of the Property type.

An equivalent and more readable way to do a type check is

if (t is Property)

Answer 5

I'd say that the first approach was probably done by someone unfamiliar with C#, not necessary being lazy. The string comparison will work for a majority of the time, except:

1. If t is null it would throw a null reference exception.
2. It doesn't take namespaces into consideration.

I would recommend the second case, unless you fall into needing the #2 edge case.