Argthtjtr

I've this comparison which equals false as expected

bool eq = typeof(int?).Equals(typeof(int));

now I have this code

List<object> items = new List<object>() { (int?)123 };

int result = items.OfType<int>().FirstOrDefault();

but this returns 123 - anyway that value is of type int?

How can this be?

Nullable types have special "boxing" rules; "boxing" is when a value-type is treated as object, as per your code. Unlike regular value-types, a nullable value-type is boxed either as null (regular null, no type), or as the non-nullable type (the T in T?). So: an int? is boxed as an int, not an int?. Then when you use OfType<int>() on it, you get all the values that are int, which is: the single value you passed in, since it is of type int.

A nullable value type is boxed by the following rules:

• If HasValue returns false, the null reference is produced.


• If HasValue returns true, a value of the underlying value type T is
  boxed, not the instance of nullable.

In your example second rule has been followed as you have value, e.g.
var i = (object)(int?)123;

It is a bit late, but beside of Marc's answer to your question, I want to give some additional information about Nullable value types in CLR.

The CLR has built-in support for nullable value types. This special support is provided for boxing, unboxing, calling GetType, calling interface methods.

For example, let's check GetType():

Int32? x = 5;

Console.WriteLine(x.GetType());

What you think it will print to the console?
System.Nullable<Int32? Not, the result is System.Int32.

Or, let's check boxing, which you noted in your question:

Int32? n =5;

Object o = n;

Console.WriteLine("o's type={0}", o.GetType()); // "System.Int32"

The rule is that:

When the CLR is boxing a Nullable instance, it checks to see if it
is null, and if so, the CLR doesn’t actually box anything, and null is
returned. If the nullable instance is not null, the CLR takes the
value out of the nullable instance and boxes it. In other words, a
Nullable with a value of 5 is boxed into a boxed-Int32 with a
value of 5.

And, at the end I want to explain how CLR add special support for calling interface methods from Nullable Types.
Let's take a look to that:

Int32? n = 5;

Int32 result = ((IComparable) n).CompareTo(5); // Compiles & runs OK

Console.WriteLine(result); // 0

In the preceding code, I’m casting n, a Nullable<Int32>, to IComparable<Int32>, an interface
type. However, the Nullable<T> type does not implement the IComparable<Int32> interface as
Int32 does. The C# compiler allows this code to compile anyway.