Question

I’m not wanting to start a flame war on micro-optimisation, but I am curious about something.

What’s the overhead in terms of memory and performance of creating instances of a type that has no intrinsic data?

For example, a simple class that implements IComparer<T> may contain only a Compare method, and no properties or fields.

class FooComprarer : IComparer<Foo>
{
    public int Compare (Foo x, Foo y) 
    {
        // blah, blah
    }
}

Typical example code I’ve seen just calls new FooComparer(), wherever one of these is needed.

I can’t imagine the instantiation cost here is very much at all, but I’m interested to know what it actually is. And how would it compare to, say, a static factory class that maintains a dictionary of types to comparers so that one comparer instance can be used everywhere it’s needed.

Answer 1

There is some overhead, but it’s probably negligible compared to what you are going to use the comparer for.

On both a 32-bit and a 64-bit system that instance will use 16 bytes of heap space. The overhead is two pointers, which use 8 bytes on a 32-bit system and 16 bytes on a 64-bit system. However, the memory manager in the 32-bit system can’t allocate blocks smaller than 16 bytes, so there will be 8 unused bytes in the block.

If you reuse those comparers a lot, you might consider to keep them around. However, you should also consider that short lived objects causes much less strain on the memory management than long lived objects, so you have to reuse the comparers a lot for it to be worth it to keep them alive.