How does a generic constraint prevent boxing of a value type with an implicitly implemented interface?

by

My question, however, is how the compiler enables a generic constraint to eliminate the need for boxing a value type that explicitly implements an interface.

By “the compiler” it is not clear whether you mean the jitter or the C# compiler. The C# compiler does so by emitting the constrained prefix on the virtual call. See the documentation of the constrained prefix for details.

What is going on with the behind-the-scenes CLR implementation that requires a value type to be boxed when accessing an explicitly implemented interface member

Whether the method being invoked is an explicitly implemented interface member or not is not particularly relevant. A more general question would be why does any virtual call require the value type to be boxed?

One traditionally thinks of a virtual call as being an indirect invocation of a method pointer in a virtual function table. That’s not exactly how interface invocations work in the CLR, but it’s a reasonable mental model for the purposes of this discussion.

If that’s how a virtual method is going to be invoked then where does the vtable come from? The value type doesn’t have a vtable in it. The value type just has its value in its storage. Boxing creates a reference to an object that has a vtable set up to point to all the value type’s virtual methods. (Again, I caution you that this is not exactly how interface invocations work, but it is a good way to think about it.)

What happens with a generic constraint that removes this requirement?

The jitter is going to be generating fresh code for each different value type argument construction of the generic method. If you’re going to be generating fresh code for each different value type then you can tailor that code to that specific value type. Which means that you don’t have to build a vtable and then look up what the contents of the vtable are! You know what the contents of the vtable are going to be, so just generate the code to invoke the method directly.

More Related Contents:

  1. How do I use reflection to call a generic method?
  2. C# Interfaces. Implicit implementation versus Explicit implementation
  3. Passing arguments to C# generic new() of templated type
  4. Understanding Covariant and Contravariant interfaces in C#
  5. What exactly is an “open generic type” in .NET? [duplicate]
  6. Generics in C#, using type of a variable as parameter [duplicate]
  7. Create instance of generic type whose constructor requires a parameter?
  8. Testing if object is of generic type in C#
  9. A generic list of anonymous class
  10. What’s the difference between SortedList and SortedDictionary?
  11. Why must I provide explicitly generic parameter types While the compiler should infer the type?
  12. C# Create New T()
  13. Func with out parameter
  14. implicit vs explicit interface implementation [duplicate]
  15. Why isn’t ArrayList marked [Obsolete]?
  16. Convert string to nullable type (int, double, etc…)
  17. How to initialize a List to a given size (as opposed to capacity)?
  18. How can I use interface as a C# generic type constraint?
  19. Generic Type in constructor
  20. Collection of generic types
  21. When is using the C# ref keyword ever a good idea?
  22. Wildcard equivalent in C# generics
  23. How is the boxing/unboxing behavior of Nullable possible?
  24. Generics can’t infer second parameter? [duplicate]
  25. Can I have a variable number of generic parameters?
  26. How can I implement static methods on an interface?
  27. Which C# method overload is chosen?
  28. How can I write a generic container class that implements a given interface in C#?
  29. generic NOT constraint where T : !IEnumerable
  30. What exactly is “interface based programming”?

Leave a Comment