C#: Alternative to GenericType == null

Question

I need to check a generic object for null, or default(T). But I have a problem... Currently I have done it like this:

if (typeof(T).IsValueType)
{
  if(default(T).Equals(thing))
    // Do something
  else
    // Do something else
}
else
{
  if(thing == null)
    // Do something
  else
    // Do something else
}

But then I end up repeating myself... which I don't like. The problem is the following:

thing == null;

Here ReSharper warns about Possible compare of value type with 'null'.

thing == default(T);

Here I get compiler error: Cannot apply operator '==' to operands of type 'T' and 'T'.

thing.Equals(null|default(T));

thing can obviously be null (that's why I have to check!), so will cause NullReferenceException.

null|default(T).Equals(thing);

null and default(T) is very often null as well...

Is there a clean way to do this??

Answer 1

Best thing I can think of at the moment is:

return value == null || value.Equals(default(T));

Edit:

Apparently, there's a static object.Equals method I was not aware of:

return object.Equals(value, default(T));

This is better.

Answer 2

A bit of boxing will do the job just fine.

    static bool IsNullOrDefault<T>(T value)
    {
        return ((object)default(T)) == null ?
            ((object)value) == null :
            default(T).Equals(value);
    }

Answer 3

With Tests:

public class DefaultOrNullChecker<T>  {
    public bool Check(object x) {
        return object.ReferenceEquals(x, null) || x.Equals(default(T));
    }
}
[TestFixture]
public class Tests {
    [Test]  public void when_T_is_reference_type() { 
        Assert.IsFalse(new DefaultOrNullChecker<Exception>().Check(new Exception()));}
    [Test] public void when_T_is_value_type() { 
        Assert.IsFalse(new DefaultOrNullChecker<int>().Check(123)); }
    [Test] public void when_T_is_null() {
        Assert.IsTrue(new DefaultOrNullChecker<Exception>().Check(null));}
    [Test] public void when_T_is_default_value() { 
        Assert.IsTrue(new DefaultOrNullChecker<int>().Check(0)); }
}

Answer 4

If boxing isn't an issue, you could just use:

object.Equals(value, default(T))

Answer 5

You can avoid boxing altogether by noting that nullability of a type can be determined statically.

Here is what you can do:

1. Declare a private static read-only variable called isDefault of type Predicate<T> in your generic class
2. Add a static initializer to your generic class, where you check T's nullability, and set isDefault to either v==null or default(T).Equals(v) depending on the outcome
3. Use isDefault(x) instead of x==null in the rest of your code

Here is an example:

public class Example<T> {

    private static readonly Predicate<T> isDefault;

    static Example() {
        // Nullability check is a bit ugly, but we do it once per T,
        // so what the heck...
        if (typeof(T).IsValueType &&
           (!typeof(T).IsGenericType
        ||  typeof(T).GetGenericTypeDefinition() != typeof(Nullable<>)
        )) {
            // This is safe because T is not null
            isDefault = val => default(T).Equals(val);
        } else {
            // T is not a value type, so its default is null
            isDefault = val => val == null;
        }
    }

    public bool Check(T value) {
        // Now our null-checking is both good-looking and efficient
        return isDefault(value);
    }

}

Answer 6

The proper way to do this is:

return EqualityComparer<T>.Default.Equals(value, default(T))

No boxing. You could even define an extension method like this:

public static void bool IsDefault<T>(this T value)
{
    return EqualityComparer<T>.Default.Equals(value, default(T));
}

.. and invoke it like this:

return entry.IsDefault();

Though, I personally don't care for extension methods on T (e.g. this object IsNull()) since it hampers readability sometimes.

Answer 7

What is wrong with this?

if (thing == default(T)) { }

If it is a value type then the JIT will simply remove the statement altogether.