An Introduction to Building .NET Reflector Add-ins

At its core, .NET Reflector is a .NET decompiler and disassembly tool, but everyone’s needs are different. You’ve probably thought of something you’d like .NET Reflector to be able to do, and are wondering if you can create an add-in to extend the core tool. Thankfully, .NET Reflector has an extensive add-in framework, and there are plenty of add-ins already available to use as examples of what can be done.

A .NET Reflector add-in is fundamentally just a dll/exe assembly file that contains packages. A package is a class that implements the IPackage interface, which defines a Load and Unload method. An IServiceProvider interface is passed during loading, and gives access to a set of services which are part of the .NET Reflector object model (the most common of which we’ll see below)

Services Available to Add-In Authors

The following table lists the most commonly-used services that can be accessed through the GetService method on IServiceProvider:

Service	Description
IAssemblyBrowser	Maintains the currently selected Code Model object in the ActiveItem property. You can assign a Code Model object like IMethodDeclaration to the ActiveItem to programatically change the currently selected item in the browser window. ActiveItemChanged notifies that the selected item has changed.
IWindowManager	Manages the application window and pane windows. You can add your own pane windows to the Windows collection which will create an IWindow hosting frame. ShowMessage can be used to show notification messages to the user.
ICommandBarManager	Manages the Reflector menu bar, tool bar and context menus. You can lookup a context menu by its identifier and add items to it.
IConfigurationManager	Manages the sections from the Reflector configuration file as a set of IConfiguration objects. Lists of items are represented as properties named “0″, “1″, “2″, …
IAssemblyManager	Maintains the list of currently loaded assemblies. LoadFile can be used to load an assembly file from disk. Unload allows you to unload an assembly from memory. The Assemblies collection holds all the currently loaded assemblies.
ILanguageManager	Manages formatting modules for different programming languages. The ActiveLanguage property exposes the ILanguage object currently used for rendering. You can add your own language rendering code by implementing the ILanguage interface. Use RegisterLanguage to add your add-in to ILanguageManager.

Although the .NET Reflector API exposes more interfaces than this, these are the most commonly used ones. We’ll list some more details below, but first let’s walk through a really simple add-in to demonstrate the basic principles.

HelloWorld Add-In

A simple “HelloWorld” add-in can be created by implementing the IPackage interface. The Load method is implemented to ask the IServiceProvider for the IWindowManager service, which allows you to communicate with .NET Reflector’s windowing system. Finally, the ShowMessage method is used to show a message to the user:

using System; using Reflector; internal class HelloWorldPackage : IPackage 
    { private IWindowManager windowManager; public void Load(IServiceProvider serviceProvider) 
        { this.windowManager = (IWindowManager) serviceProvider.GetService(typeof(IWindowManager));
                               this.windowManager.ShowMessage("Loading HelloWorld!"); 
        } public void Unload() 
        { this.windowManager.ShowMessage("Unloading HelloWorld!"); 
        } 
    }

The code can be compiled into an add-in dll, which is referencing Reflector.exe as a library:

csc.exe /target:library /out:HelloWorld.dll *.cs /r:Reflector.exe

The add-in can then be copied to your Reflector directory and loaded using the View | Add-Ins menu. While this is a very basic add-in, the fundamentals of the construction and implementation don’t change. Let’s take a quick look at a how to add some more useful functionality to your add-in.

Adding Items to Command Bars and Context Menus

The ICommandBarManager service allows you to add menu items to the .NET Reflector main menu and context menus. Each submenu and context menu is registered in the CommandBars collection with an identifier name, and the following table lists the most commonly used identifiers:

Identifier	Description
Tools	The tools menu shown as part of the main menu.
Browser.Assembly	The context menu for the currently selected assembly.
Browser.Namespace	The context menu for the currently selected namespace.
Browser.TypeDeclaration	The context menu for the currently selected type declaration.
Browser.MethodDeclaration	The context menu for the currently selected method declaration.

Next Steps

Thoroughly documenting the .NET Reflector API is something we’ll be working on in the near future. In the meantime, Jason Haley has some excellent walkthroughs:

• Getting Started with .NET Reflector add-ins
• Create your own add-in : The basics
• Create your own add-in : More details
• Wrapping .NET Reflector

For more examples, you can take a look at:

• Peli de Halleux’s excellent .NET Reflector Add-in Tutorial
• Jamie Cansdale’s excellent article “Building the .NET Reflector Add-in”.

Each of these examples will give you an example of writing a different add-in, with varying degrees of complexity. The basic advice will be the same, though: Get stuck in and play around. Take a look at other add-ins (many of which are open-source) and see what makes them tick. Even use .NET Reflector on itself to find all the relevant classes in Reflector.CodeModel. At this stage, experimentation is the name of the game, but we’ll be taking out the guesswork real soon.

In the meantime, feel free to take a look at the add-ins and tools that are already available.