I, like many, was disappointed when I heard that Reflector 7 was not free, and perhaps that’s why I waited so long to try it and just kept using my version 6 (which continues to be free).  But though I resisted for so long, I longed for the better features that were being developed, and began to wonder if I should upgrade.  Thus, I began to look into the features being offered in Reflector 7.5 to see what was new.

Multiple Editions

Reflector 7.5 comes in three flavors, each building on the features of the previous version:

• Standard – Contains just the Standalone application ($70)
• VS – Same as Standard but adds Reflector Object Browser for Visual Studio ($130)
• VSPro – Same as VS but adds ability to set breakpoints and step into decompiled code ($190)

So let’s examine each of these features.

The Standalone Application (Standard, VS, VSPro editions)

Popping open Reflector 7.5 and looking at the GUI, we see much of the same familiar features, with a few new ones as well:

Most notably, the disassembler window now has a tabbed window with navigation buttons.  This makes it much easier to back out of a deep-dive into many layers of decompiled code back to a previous point.

Also, there is now an analyzer which can be used to determine dependencies for a given method, property, type, etc. For example, if we select System.Net.Sockets.TcpClient and hit the Analyze button, we’d see a window with the following nodes we could expand:

This gives us the ability to see what a given type uses, what uses it, who exposes it, and who instantiates it. Now obviously, for low-level types (like DateTime) this list would be enormous, but this can give a lot of information on how a given type is connected to the larger code ecosystem.

One of the other things I like about using Reflector 7.5 is that it does a much better job of displaying iterator blocks than Reflector 6 did. For example, if you were to take a look at the Enumerable.Cast() extension method in System.Linq, and dive into the CastIterator in Reflector 6, you’d see this:

But now, in Reflector 7.5, we see the iterator logic much more clearly:

This is a big improvement in the quality of their code disassembler and for me was one of the main reasons I decided to take the plunge and get version 7.5.

The Reflector Object Browser (VS, VSPro editions)

If you have the .NET Reflector VS or VSPro editions, you’ll find you have in Visual Studio a Reflector Object Browser window available where you can select and decompile any assembly right in Visual Studio.

For example, if you want to take a peek at how System.Collections.Generic.List<T> works, you can either select List<T> in the Reflector Object Browser, or even simpler just select a usage of it in your code and CTRL + Click to dive in.

–

And it takes you right to a source window with the decompiled source:

Setting Breakpoints and Stepping Into Decompiled Code (VSPro)

If you have the VSPro edition, in addition to all the things said above, you also get the additional ability to set breakpoints in this decompiled code and step through it as if it were your own code:

This can be a handy feature when you need to see why your code’s use of a BCL or other third-party library isn’t working as you expect.

Summary

Yes, Reflector is no longer free, and yes, that’s a bit of a bummer. But it always was and still is a very fine tool. If you still have Reflector 6, you aren’t forced to upgrade any longer, but getting the nicer disassembler (especially for iterator blocks) and the handy VS integration is worth at least considering upgrading for. 

So I leave it up to you, these are some of the features of Reflector 7.5, what’s your thoughts?