boxing

struct Point { public int x; public int y; } void Main() { Point p; p.x = 1; p.y = 1; Object o = p; ((Point) o).x = 4; // error ((Point) o).x = 5; // error ((Point) o).x = 6; // error p = (Point) o // expect 6 } Why doesn't it compile to ldloc.1 // o unbox Point ldc.i4.4 stfld Point.x Where C++ CLI allows it. For those who don't know, unbox is not required to create a copy of value types , instead it pushes a pointer to the value on to the stack. Only assignment would create a copy. Because of how value types work, the boxed Point is a copy of the original, and "unboxing" it by casting back to

This is something I had not noticed until today. Apparently, the .NET implementation of the much used tuple classes ( Tuple<T> , Tuple<T1, T2> etc) causes boxing penalties for value types when equality based operations are performed. Here is how the class is kind of implemented in the framework (source via ILSpy): public class Tuple<T1, T2> : IStructuralEquatable { public T1 Item1 { get; private set; } public T2 Item2 { get; private set; } public Tuple(T1 item1, T2 item2) { this.Item1 = item1; this.Item2 = item2; } public override bool Equals(object obj) { return this.Equals(obj,

I'm having a hard time understanding this. Consider the following example: protected void Page_Load(object sender, EventArgs e) { // No surprise that this works Int16 firstTest = Convert.ToInt16(0); int firstTest2 = (int)firstTest; // This also works object secondTest = 0; int secondTest2 = (int)secondTest; // But this fails! object thirdTest = Convert.ToInt16(0); int thirdtest2 = (int)thirdTest; // It blows up on this line. } The specific error that I get at runtime is Specified cast is not valid. If I QuickWatch (int)thirdTest in Visual Studio, I get a value of Cannot unbox 'thirdTest' as a

So I understand what boxing and unboxing is. When's it come up in real-world code, or in what examples is it an issue? I can't imagine doing something like this example: int i = 123; object o = i; // Boxing int j = (int)o; // Unboxing ...but that's almost certainly extremely oversimplified and I might have even done boxing/unboxing without knowing it before. Jon Skeet It's much less of an issue now than it was prior to generics. Now, for example, we can use: List<int> x = new List<int>(); x.Add(10); int y = x[0]; No boxing or unboxing required at all. Previously, we'd have had: ArrayList x =

This snippet is not compiled in LINQPad. void Main() { (new[]{0,1,2,3}).Where(IsNull).Dump(); } static bool IsNull(object arg) { return arg == null; } The compiler's error message is: No overload for 'UserQuery.IsNull(object)' matches delegate 'System.Func' It works for a string array, but doesn't work for int[] . It's apparently related to boxing, but I want to know the details. The answer given (that there is no variance involving value types) is correct. The reason covariance and contravariance do not work when one of the varying type arguments is a value type is as follows. Suppose it did