boxing

I'm trying to collect all of the situations in which boxing occurs in C#: Converting value type to System.Object type: struct S { } object box = new S(); Converting value type to System.ValueType type: struct S { } System.ValueType box = new S(); Converting value of enumeration type to System.Enum type: enum E { A } System.Enum box = E.A; Converting value type into interface reference: interface I { } struct S : I { } I box = new S(); Using value types in C# string concatenation: char c = F(); string s1 = "char value will box" + c; note: constants of char type are concatenated at compile time

What is the difference between boxing/unboxing and type casting? Often, the terms seem to be used interchangeably. Boxing refers to a conversion of a non-nullable-value type into a reference type or the conversion of a value type to some interface that it implements (say int to IComparable<int> ). Further, the conversion of an underlying value type to a nullable type is also a boxing conversion. (Caveat: Most discussions of this subject will ignore the latter two types of conversions.) For example, int i = 5; object o = i; converts i to an instance of type object . Unboxing refers to an

Something just occurred to me earlier today that has got me scratching my head. Any variable of type Nullable<T> can be assigned to null . For instance: int? i = null; At first I couldn't see how this would be possible without somehow defining an implicit conversion from object to Nullable<T> : public static implicit operator Nullable<T>(object box); But the above operator clearly does not exist, as if it did then the following would also have to be legal, at least at compile-time (which it isn't): int? i = new object(); Then I realized that perhaps the Nullable<T> type could define an