How do I compare a generic type to its default value?

Question

void Get<T>(Action<T> createObject)
{
    T obj = createObject();
    if(obj == default(T))
        return obj;

    // .. do a bunch of stuff
    return obj;
}

Compiler error: Operator '==' cannot be applied to operands of type 'T' and 'T'

How do I do this properly?

Answer 1

(Edited)

Marc Gravell has the best answer, but I wanted to post a simple code snippet I worked up to demonstrate it. Just run this in a simple C# console app:

public static class TypeHelper<T>
{
    public static bool IsDefault(T val)
    {
         return EqualityComparer<T>.Default.Equals(obj,default(T));
    }
}

static void Main(string[] args)
{
    // value type
    Console.WriteLine(TypeHelper<int>.IsDefault(1)); //False
    Console.WriteLine(TypeHelper<int>.IsDefault(0)); // True

    // reference type
    Console.WriteLine(TypeHelper<string>.IsDefault("test")); //False
    Console.WriteLine(TypeHelper<string>.IsDefault(null)); //True //True

    Console.ReadKey();
}

One more thing: can someone with VS2008 try this as an extension method? I'm stuck with 2005 here and I'm curious to see if that would be allowed.

---

Edit: Here is how to get it working as an extension method:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
     // value type
     Console.WriteLine(1.IsDefault());
     Console.WriteLine(0.IsDefault());

     // reference type
     Console.WriteLine("test".IsDefault());
     // null must be cast to a type
     Console.WriteLine(((String)null).IsDefault());
    }
}

// The type cannot be generic
public static class TypeHelper
{
    // I made the method generic instead
    public static bool IsDefault<T>(this T val)
    {
     return EqualityComparer<T>.Default.Equals(val, default(T));
    }
}

Answer 2

To handle all types of T, including where T is a primitive type, you'll need to compile in both methods of comparison:

    T Get<T>(Func<T> createObject)
    {
        T obj = createObject();
        if (obj == null || obj.Equals(default(T)))
            return obj;

        // .. do a bunch of stuff
        return obj;
    }

EDIT: Marc's answer (below) is more correct: avoids boxing entirely when possible and respects custom equality implementations to boot.

Answer 3

There is going to be a problem here -

If you're going to allow this to work for any type, default(T) will always be null for reference types, and 0 (or struct full of 0) for value types.

This is probably not the behavior you're after, though. If you want this to work in a generic way, you probably need to use reflection to check the type of T, and handle value types different than reference types.

Alternatively, you could put an interface constraint on this, and the interface could provide a way to check against the default of the class/struct.

Answer 4

To avoid boxing, the best way to compare generics for equality is with EqualityComparer<T>.Default. This respects IEquatable<T> (without boxing) as well as object.Equals, and handles all the Nullable<T> "lifted" nuances. Hence:

if(EqualityComparer<T>.Default.Equals(obj,default(T)) {
    return obj;
}

This will match:

• null for classes
• null (empty) for Nullable<T>
• zero/false/etc for other structs