C# - <T> object casting

Question

As far as I know, if we're dealing with COM interfaces, any simple cast will usually trigger the QueryInterface routine, which is used to determine if the object actually implements the corresponding COM interface.

object whatever;
IComInterface casted = (IComInterface) whatever;

Hence, the following code, depending on the compiler and optimizations might trigger the QueryInterface in the internal object casting implementation:

IComInterface comInteface;

// I guess nothing COM-related happens here, but I might be wrong
object whatever = comInteface; 

// This might or might not trigger the 'QueryInterface' call.
IComInterface comInterface2 = (IComInteface) whatever;

---

Q:

Suppose I have a generic List<T> instance:

List<IComInterface> list = new List<IComInterface>();

Now, do I have a strong guarantee that the following code would not trigger the QueryInterface-based cast?

List<IComInterface> list = new List<IComInterface>();
IComInterface comInterface = (...); // Somehow got it.
list.Add(comInteface);
IComInterface retrieved = list[0];

• Using ArrayList instead of List<T> here actually results in the cast performed, because you have to get the corresponding IComInterface from your typeless object instance.

• However, in case of generics, I guess, everything should be done without casting, but I'm not actually sure about how they work under the surface.

• Is it possible that List<T> still somehow operates with object types (and, hence, will invoke the QueryInterface-based cast in the described scenario)?

• If the answer to the previous question is "no", is it true, that you can't guarantee the same for any possible IList<T>?

Answer 1

Yes, that's a pretty decent guarantee, the compiler won't emit a Opcodes.Castclass IL instruction unless it has to. The type matches so no need to for the cast.

This should not in general concern you. The QI implementation of a COM interface gets hammered for all kinds of reasons, internal to COM. It is always very fast, comparing a guid takes but a handful of nanoseconds.

Answer 2

You can think of generic type instances (e.g. List<IComInterface>) as of classes created from generic type definitions (e.g. List<T>) by literally replacing the name T with the name IComInterface. The type is not "erased" the way it is done in some languages (most notably, Java), it is kept with the generic type instance, so that all variables declared as type T in the generic type definition remain strongly typed in the generic type instance.

In case of a List<IComInterface>, there is no cast to or from object as long as you insert objects that are known to be of IComInterface type at compile time. This is the case in the code from your post, but it may not always be true. For example, when you insert a dynamically typed object, the compiler will add a cast:

dynamic comInteface = ...
list.Add(comInteface); // There will be an implicit cast here