boxing

What i'm trying to achieve here is a straight value comparison of boxed primitive types. ((object)12).Equals((object)12); // Type match will result in a value comparison, ((object)12).Equals((object)12d); // but a type mismatch will not. (false) object.Equals((object)12,(object)12d); // Same here. (false) I understand the 'why'. I just don't see a 'how'. The types are unknown until runtime, where they could be any primitive type from a datasource. That includes strings, datetimes, bools, etc. I've gone down the ugly route of writing an extension method that works out both types, and then casts

This question already has an answer here: Boxing when using generics in C# 2 answers Why a generic method which constrains T to class would have boxing instructions in the generates MSIL code? I was quite surprised by this since surely since T is being constrained to a reference type the generated code should not need to perform any boxing. Here is the c# code: protected void SetRefProperty<T>(ref T propertyBackingField, T newValue) where T : class { bool isDifferent = false; // for reference types, we use a simple reference equality check to determine // whether the values are 'equal'. We do

Does boxing/unboxing occur when a method accepts an out/ref parameter of a ValueType? For ref Keyword Its already mentioned on MSDN that : Do not confuse the concept of passing by reference with the concept of reference types. The two concepts are not the same. A method parameter can be modified by ref regardless of whether it is a value type or a reference type. There is no boxing of a value type when it is passed by reference. As for out keyword: The out keyword causes arguments to be passed by reference . This is like the ref keyword, except that ref requires that the variable be

I am mystified by the behavior of the Java compiler when assigning primitives to wrapper class references. Please see the code below. The lines with comments don't compile. I don't understand the logic of why: a byte can be assigned to a Byte or Short , but not Integer or Long reference a short can be assigned to a Byte or Short , but not Integer or Long reference an int can be assigned to a Byte , Short , or Integer , but not Long reference a long can be assigned to a Long , but not Byte , Short or Integer reference I cannot see the pattern. Any insight into this will be really helpful.

Possible Duplicates: Why do we need boxing and unboxing in C#? What is boxing and unboxing and what are the trade offs? In C# what doe sit means: "Box and UnBox"? Here an extract from MSDN where I founded the Text. But this convenience comes at a cost. Any reference or value type that is added to an ArrayList is implicitly upcast to Object. If the items are value types, they must be boxed when they are added to the list, and unboxed when they are retrieved. Both the casting and the boxing and unboxing operations decrease performance; the effect of boxing and unboxing can be very significant in

I am curious to know if all casts in C# result in boxing, and if not, are all casts a costly operation? Example taken from Boxing and Unboxing (C# Programming Guide) int i = 123; // The following line boxes i. object o = i; This line obviously causes boxing (wrapping up the int type as an object). This is an operation that is considered costly, since it creates garbage that will be collected. What about casts from 2 different types of reference types? what is the cost of that? can it be properly measured? (compared to the previous example) For example: public class A { } public class B : A { }

For a numeric intensive code I have written a function with the following signature: def update( f: (Int,Int,Double) => Double ): Unit = {...} However, because Function3 is not specialized, every application of f results in boxing/unboxing the 3 arguments and the result type. I could use a special updater class: trait Updater { def apply( i: Int, j: Int, x: Double ): Double } def update( f: Updater ): Unit = {...} But the invocation is cumbersome (and java-ish): //with function b.update( (i,j,_) => if( i==0 || j ==0 ) 1.0 else 0.5 ) //with updater b.update( new Updater { def apply( i: Int, j: