Best .NET Profiling tool (performance and memory)

http://memprofiler.com/

I really like this tool for memory key feature for me is the ability to load a memory dump. If you aren't using them yet I would highly recommend reading up on them and SOS as they are your best tools for looking at memory usage.

Personally I am not really fond of any of these tools for performance tuning. Why? Because they all suffer from the uncertainty principle, they change what you are measuring when they inject your code. As a perfect example... It would say this is slow

public class Flock {
    private int numberOfBirds;
    private decimal [,] someMatrixOfBirdData;
    public int NumberOfBirds { get { return numberOfBirds(); } }

    .
    .
    .
    for(int i=0;i < this.NumberOfBirds; i++) {
        //do something with birdmatrix
    }


it will report this as being really slow because when it injects code into the NumberOfBirds property at runtime it makes it so inlining no longer happens on the property. The inlining not happenning causes the condition to no longer be hoisted out of the loop. This in turn causes the method to be called on every iteration.

These may seem like minor things but they can easily add up.

Personally I use aspects to drop in measurements at higher level places and have some custom code for measuring other things that I use for performance testing. Once I identify an area thats slow, finding the cause is usually the easy part :)

I use AOP (aspect oriented programming) to drop in measurements generally at facade boundaries .. this allows me to at runtime introduce measurements as I see fit. I find that facade boundaries (or service/repository boudaries in the domain) really do the trick well.

Once I see that something is out of wack ... looking through the code base philosophically is generally enough for me. Given it is a skill that is learned with practice to hone in on areas without seeing them run but I find when I give Jr guys (we call them apprentices) a tool like this for performance it tends to do more harm than good (they often end up focused on the code at hand and not up a level where they should be thinking algorithmically). i.e. they focus on micro-optimizations and miss the algorithmic optimization staring them in the face.

Again this has just been my experience ...

I also deal ALOT with heavily threaded code and in heavily threaded code this type of performance is all but useless :)