Boxing Occurrence in C#

by

That’s a great question!

Boxing occurs for exactly one reason: when we need a reference to a value type. Everything you listed falls into this rule.

For example since object is a reference type, casting a value type to object requires a reference to a value type, which causes boxing.

If you wish to list every possible scenario, you should also include derivatives, such as returning a value type from a method that returns object or an interface type, because this automatically casts the value type to the object / interface.

By the way, the string concatenation case you astutely identified also derives from casting to object. The + operator is translated by the compiler to a call to the Concat method of string, which accepts an object for the value type you pass, so casting to object and hence boxing occurs.

Over the years I’ve always advised developers to remember the single reason for boxing (I specified above) instead of memorize every single case, because the list is long and hard to remember. This also promotes understanding of what IL code the compiler generates for our C# code (for example + on string yields a call to String.Concat). When your’e in doubt what the compiler generates and if boxing occurs, you can use IL Disassembler (ILDASM.exe). Typically you should look for the box opcode (there is just one case when boxing might occur even though the IL doesn’t include the box opcode, more detail below).

But I do agree that some boxing occurrences are less obvious. You listed one of them: calling a non-overridden method of a value type. In fact, this is less obvious for another reason: when you check the IL code you don’t see the box opcode, but the constraint opcode, so even in the IL it’s not obvious that boxing happens! I won’t get into the exact detail why to prevent this answer from becoming even longer…

Another case for less obvious boxing is when calling a base class method from a struct. Example:

struct MyValType
{
    public override string ToString()
    {
        return base.ToString();
    }
}

Here ToString is overridden, so calling ToString on MyValType won’t generate boxing. However, the implementation calls the base ToString and that causes boxing (check the IL!).

By the way, these two non-obvious boxing scenarios also derive from the single rule above. When a method is invoked on the base class of a value type, there must be something for the this keyword to refer to. Since the base class of a value type is (always) a reference type, the this keyword must refer to a reference type, and so we need a reference to a value type and so boxing occurs due to the single rule.

Here is a direct link to the section of my online .NET course that discusses boxing in detail: http://motti.me/mq

If you are only interested in more advanced boxing scenarios here is a direct link there (though the link above will take you there as well once it discusses the more basic stuff): http://motti.me/mu

I hope this helps!

Motti

More Related Contents:

  1. Structs, Interfaces and Boxing [duplicate]
  2. Why doesn’t delegate contravariance work with value types?
  3. What is the difference between a reference type and value type in c#?
  4. In C#, why is String a reference type that behaves like a value type?
  5. Why do we need boxing and unboxing in C#?
  6. How do ValueTypes derive from Object (ReferenceType) and still be ValueTypes?
  7. Detailed Explanation of Variable Capture in Closures
  8. Changing the value of an element in a list of structs
  9. C# pass by value vs. pass by reference
  10. Comparing boxed value types
  11. C#: Getting size of a value-type variable at runtime?
  12. How is the boxing/unboxing behavior of Nullable possible?
  13. C# – Issues with boxing / unboxing / typecasting ints. I don’t understand
  14. How does a generic constraint prevent boxing of a value type with an implicitly implemented interface?
  15. Why Enum’s HasFlag method need boxing?
  16. What is the purpose of the “Prefer 32-bit” setting in Visual Studio and how does it actually work?
  17. C# Point in polygon
  18. In my WPF application, my loaded PNG logo in image shows at design time but not at run time
  19. Deserializing JSON when key values are unknown
  20. Build error: You must add a reference to System.Runtime
  21. Creating Composite Key Entity Framework
  22. Why can’t I call an extension method from a base class of the extended type‏?
  23. string.IsNullOrEmpty(string) vs. string.IsNullOrWhiteSpace(string)
  24. Set focus on textbox in WPF
  25. Linq distinct – Count
  26. How to pass multiple parameters to a get method in ASP.NET Core
  27. When is ReaderWriterLockSlim better than a simple lock?
  28. NHibernate.MappingException: No persister for: XYZ
  29. How to bind Dataset to DataGridView in windows application
  30. Find a file within all possible folders?

Leave a Comment