Comparing an instance of a type param to null, even with no class constraint?

Question

The following code compiles:

class Testing<TKey, TValue>
{
    public bool Test(TKey key)
    {
        return key == null;
    }
}

However, TKey can be a value type, and possibly not allow the value "null".

I know the results of this program, and how to add constraints. What I'm wondering is why doesn't the compiler disallow this when TKey is not constrained to "class"?

Answer 1

As for the "why", I'm not sure. But to fix it, you can use default(T) instead of null.

Answer 2

It's convenient to be able to do this in various cases. If TKey is a non-nullable value type, the result of the comparison will always be false. (It's possible that the JITter will remove that branch entirely - don't forget that although one version of the JITted code is shared for all reference types, it reJITs for each value type.)

EDIT: One interesting use for this is precisely to allow Nullable<T> comparisons with null. TFoo=Nullable<T> doesn't satisfy either the where TFoo : class or where TFoo : struct constraints.

Answer 3

Because it cast your variable to object and use object == operator For a value type it's always false.

Answer 4

because everything in csharp is an object.
in other words Every type in C# directly or indirectly derives from the object class type.
example

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        struct SimpleStruct
        {
            int a;
            public SimpleStruct(int a)
            {
                this.a = a;
            }
        }
        enum SimpleEnum
        {
            a = 1,
            b = 2,
        }

        static void Main(string[] args)
        {
            SimpleStruct tp = new SimpleStruct(2);

            object ob = tp;
            if (ob != null)
            {
                Console.WriteLine("struct is an object : " + ob);
                tp = (SimpleStruct)ob;
            }

            SimpleEnum tp2 = SimpleEnum.a;
            ob = tp2;
            if (ob != null)
            {
                Console.WriteLine("enum is an object : " + ob);
                tp2 = (SimpleEnum)ob;
            }
            Console.ReadKey();
        }
    }
}

Answer 5

Because TKey could be nullable type.

Since C# 2.0 struct is comparable with null. That's why you can write 0 == null with no compile error.