.NET is a fantastic platform to lose performance. It has a nice set of high-level languages, powerful standard library and lots of useful assemblies available. Its runtime is so good you don't have to worry about effectiveness most of the time. You just build your application one layer of abstraction over another until it's ready. Of course, every layer eats up a bit of performance, but it's a fair trade-off: you sure loose some machine cycles here and there, but you win in productivity because of a high-level environment. 

Yet once in a while, you may run into a situation, when you do have to worry about performance. For me, it was with the image processing application I wrote in 2013. It was working fine with my own test pictures, which were relatively small. But the very first real world user tried to process a 10 000 x 20 000 px page scan with it and the whole thing just hanged. It was working well, but as the processing took over several minutes, it was considered not responding and forced to quit. 

Usually, it's the algorithm. Algorithmic improvements can be the most drastic, but I knew from my experience, that the mathematical model behind the product was hardly an issue. It is nothing more a light-weight polynomial model combined with a simple affine transformation. So the problem had to be in the environment. Somehow trivial tasks appeared to be much more time consuming than they look. 

To peek inside these seemingly trivial things, I had to use disassembler. I took ILDasm for getting intermediate language assembly code and a Visual Studio built-in disassembler for the machine-level code. This way I learned quite a lot about how .NET works including C# compilation, just-in-time compilation, library data types and methods. The experience obtained helped me make the tightest parts of my code up to 100 times faster. A huge gain.  

Now I want to share this experience with you.