Seamlessly debug into third-party code and assemblies

Find and fix bugs, fast

Decompile, understand, and fix any .NET code,
even if you don't have the source

Look inside any .NET code

  • Debugging your application
    • Follow bugs through your application to see where your problems lie – whether it's in your own code, third-party libraries, or components used by your application.
  • Understand how applications work
    • Inherited applications with little or no documentation or comments are hard to develop. Use .NET Reflector to understand how the code runs and avoid bugs.
  • SharePoint and other third-party platforms
    • Like many third-party platforms, SharePoint APIs and libraries aren't always well-documented. With .NET Reflector you can look inside their assemblies and see how they work and which APIs you can call.

Code smarter with .NET Reflector

.NET Reflector saves time and simplifies development by letting you see and debug into the source of all the .NET code you work with.

Development is increasingly dependent on third-party technologies – using available frameworks and libraries is a great way to get stuff done fast without re-inventing the wheel.

But the problem with using code you didn't write is that you're dependent on the documentation, and it's hard to debug. Documentation is often missing or incomplete, and debugging has to stop where your own code stops. This gets even worse with a legacy code base. Use .NET Reflector to look into the black box of missing or undocumented source code and start coding with confidence.

Video Tour

EVERY DEVELOPER NEEDS THIS TOOL. The ability to step into third–party code including Microsoft SharePoint Server assemblies opens up new possibilities and lets you understand what Microsoft's APIs are doing. … You can step right into their code and see what it happening, all from Visual Studio. This knowledge lets you build better applications, and provides insight into undocumented APIs.

Daniel Larson, Software Architect, NewsGator Technologies
Check out our .NET tool collections

.NET Reflector is available in 2 editions or as part of our .NET Developer Bundle.

Pricing information

How .NET Reflector can help you

Makes all .NET code readable

.NET Reflector is an extremely fast debugging and decompilation tool that lets you look inside code, even when you don't have the source. Track your data flow through third party libraries and frameworks like ASP.NET, Silverlight, and Enterprise library.

.NET Reflector lets you debug third party code in visual studio as if it's your own. Discover whether bugs are in your code or in third party components, and make development on platforms like SharePoint and Umbraco easier. Generate PDBs, attach breakpoints, and debug live to see how your application behaves in real time.

Build checking and code recovery

Make sure you're shipping the right code, and that your code is protected. Check that the right versions of the right components are present, and use Reflector to look at the final code you're shipping and ensure your obfuscation is effective.

Missing or corrupted check-ins can leave you with an executable but no source code. Source code can also be accidentally deleted or corrupted, and backups can fail. Reflector lets you look inside DLLs and .exe files so you can understand how apps were built, and start to reconstruct missing code.

Standard edition features

  • Use .NET Reflector to decompile assemblies


    Decompile, browse, and analyze any .NET assembly to C#, VB.NET, or IL.

  • The .NET Reflector desktop application

    Desktop Application

    Use the standalone application to explore and navigate decompiled code

  • The .NET Reflector search filtering in the desktop application

    Search filtering

    Get results as you type and find what you're looking for easily.

Debug and decompile inside Visual Studio

  • Use the VS debugger screenshot

    Use the VS debugger

    Use your regular debugging techniques on any decompiled assemblies as if they were your own using the Visual Studio debugger.

  • Debug third-party assemblies screenshot

    Debug third-party assemblies

    Generate PDB files for decompiled assemblies and save them so you only need to enable debugging once for each assembly.

  • Dynamic decompilation screenshot

    Dynamic decompilation

    Assemblies decompile seamlessly in Visual Studio so source code is always available for your libraries.

  • Use VS shortcuts screenshot

    Use VS shortcuts

    Use F12 to “Go To Definition”, F9 to “Set Breakpoints”, and F11 to “Step Into” any decompiled code.

  • C#5 decompilation screenshot

    C#5 decompilation

    .NET Reflector supports C#5 and .NET 4.5 so you can decompile and learn async code at the same time.

  • Browse assemblies screenshot

    Browse assemblies

    .NET Reflector VSPro adds the Reflector Object Browser into Visual Studio. Use the tree view to navigate through code.

3 ways .NET Reflector will make your life easier

Debug third-party code, fast

look inside any .NET code

Using third-party technologies is a great way to get stuff done fast without re-inventing the wheel. But it's hard to debug libraries, components, and frameworks you didn't write.

.NET Reflector saves time and simplifies development by letting you see and debug into the source of all the .NET code you work with.

Follow bugs through your own code, third-party components, and any compiled .NET code you work with. You can see third-party code in Visual Studio, and debug into it just like your own.

  • See how code works

    Follow data

    See how data flows through a library or component, and watch locals change as you debug.

  • Find and fix bugs by enabling debegging in Visual Studio

    Find bugs

    Track down the exact location of bugs in your own code or third-party libraries.

  • Find dependencies in third-party code

    Get insight

    Find dependencies, diff assemblies, and understand how code works.

Easily work with anyone's code

look inside any .NET code

Languages and libraries aren't always well-documented; legacy code isn't always well-commented. Understand how APIs, components, frameworks, and all the critical code you use really works by decompiling and seeing inside.

Having the source code available means you're no longer blocked by poor or missing documentation. So you can see how code runs, avoid bugs and develop more easily with 3rd party technologies.

  • See how code works

    Better docs

    Replace poor or missing documentation by seeing how the code works in context.

  • Find unexposed and undocumented functionality

    Discover methods

    Find unexposed and undocumented functionality and get more out of the APIs and technologies you're using.

  • See how code works

    Learn tech

    Drill into how .NET languages and frameworks are implemented, and learn how to use them.

Simplify SharePoint development

look inside any .NET code

SharePoint APIs and libraries aren't always well-documented, or exposed in the way you need. But that doesn't have to be a problem.

With .NET Reflector you can look inside the SharePoint assemblies and understand exactly how they work.

  • See how code works

    Look inside

    Create better controls, WebParts, and features by seeing how they work, and how the code runs.

  • fix bugs by enabling debegging in Visual Studio

    Fix bugs

    Track down the source of errors in your own code or the SharePoint libraries.

  • Find unexposed and undocumented functionality

    Get insight

    Find out what methods to call and how they work, without relying on documentation.

Example: Debugging SharePoint customizations with .NET Reflector

A simple example of debugging an unexpected SharePoint error by looking inside the code.

Working with HTTP modules and page validation

Working around “The security validation for this page is invalid” errors, when setting the AllowUnsafeUpdates property.

Debugging into SharePoint – enabling local variables in hosted assemblies

A walkthrough of how to view local variables in SharePoint w3wp hosted assemblies

How developers are solving their problems with .NET Reflector:

.NET Reflector can also help you easily work with anyone's code and debug 3rd-party code.

.NET Reflector Add-ins

NET Reflector has a comprehensive add-in model, with an API that lets you extend the tool to suit to your exact needs. The API also lets other tools take advantage of .NET Reflector's unparalleled decompilation and disassembly abilities to complement their own functionality. The best thing is, building your own add-in is painless.

Below are some great add-ins and tools which we recommend you try out, and there are more you can download. We've done our best to find some of the best add-ins around, but you can still recommend others which you think we should feature. Or better still, why not write you own? We have links to some great tutorials to get you started:

.NET Obfuscation Checker

In addition to the add-ins below, Red Gate has come up with the .NET Obfuscation Checker, a tool designed to work with .NET Reflector.

The Obfuscation Checker scans a directory and inspects the assemblies and .exe files inside. It shows you which DLLs and executables are there, the references for each, and information about their obfuscation state and security level.

The Obfuscation Checker uses .NET Reflector to decompile the assemblies, so you can quickly see the code in a DLL or .exe file. This lets you see what's obfuscated, and what isn't. For example, you can see how readable type names are and how easy it is to understand control flow.


SmokeTest lets you invoke any member of a class interactively. An indispensable tool for anyone involved in developing, testing and managing Windows .net projects.

Created by Wesley Steiner

Main SmokeTest panel showing FileStream class Drill-down pop-up dialog into the FileStream instance


The SmokeTest panel will pop-up when you select a class in Reflector. The panel displays all static members of the class arranged by Constructors, Methods, Properties and Fields. Selecting a member presents a list of arguments you can edit as input. Invoking the member calls the function and returns the resulting instance then “drill-down” into the instance and repeat the process for all members, not just the static ones.


  • Simple and intuitive interface to invoke Constructors, Methods, Properties and Fields.
  • Enter built-in type arguments (int, char, string etc.) as text.
  • Create and edit instances of concrete classes as arguments.
  • Displays time statistics for each invoke.
  • Choose from a tree of derived types when creating an instance of a reference Type argument
  • Drill-down into the return object and SmokeTest it


Diff lets you compare two assemblies and view the differences between them. It does exactly what the name suggests, and does it well.

Created by Sean Hederman

Diff screenshot including Deletes Diff screenshot without Deletes


Palantir's Reflector.Diff performs high speed differencing between assemblies to help you visualise the changes between them.


  • Choose Framework version to compare the assembly to (must be installed on the machine)
  • Browse for a specific assembly
  • High speed differencing with background processing
  • Differences displayed inline
  • Difference Viewer virtually identical to standard Disassembler window


Reflexil is an advanced assembly editor, able to manipulate IL code and save the modified assemblies to disk. Reflexil also supports ‘on the fly' C# and VB.NET code injection.

Created by Sebastien Lebreton

C#VB.NET injection support with intellisense IL instruction editor


.NET Reflector is a great tool for doing an in-depth examination of various types of assemblies and also for disassembling IL code towards a supported .NET language. However, Reflector is not designed to modify either the structure or the IL code of assemblies. Reflexil allows such modifications and is directed especially towards IL code handling. It accomplishes this by proposing a complete instruction editor and by allowing C# / VB.NET code injection.


  • Alter any .NET assembly (exe or dll file) without source code
  • Complete IL Editor
  • On the fly VB.NET or C# compilation (v2.0, v3.5, v4.0) and injection
  • Strong name removal
  • Rename, delete or add types, methods, fields, events, … to an assembly
  • PEVerify wrapper

Assembly Visualizer

Assembly Visualizer is an open-source data visualization add-in, created for more convenient assemblies investigation.

Created by Denis Markelov

Enhanced types search Type hierarchies visualization


Assembly Visualizer gives you an ability to take from assemblies as much information as you can with a minimum amount of actions. It has several components, showing data from different perspectives.


  • Search for types in specified assemblies
  • Types sorting by descendants or members count
  • Types filtering by nature (enum, interface, etc.) and visibility
  • Ability to view enum and interface members right from the search in tooltips
  • Visualization of type hierarchy from base to descendants
  • Browsing type hierarchy from type to its supertypes
  • Highlighting of virtual members and their overrides
  • Members filtering by nature (method, field, etc.) and visibility
  • Visualization of interactions between members of one or more types
  • Drawing full dependency graph for selected assemblies


Snippy is a light weight snippet compiler originally created by Jon Skeet for his book C# in Depth: What you need to master C# 2 and 3, and later turned it into a Reflector add-in by Jason Haley.

Created by Jason Haley

OPening and building an existing snuippet from Jon Skeet's book General Snippy options, matching the functionality of Jon's tool

The features of the Reflector Add-in match the features of Jon Skeet's WPF Snippy (or did at the time Jason wrote the add-in).


  • Attempts to build C# code typed in the Snippy Window. When you compile, any build messages (including error messages from the build) are written to the Output Window – which only shows after a Build has been called for
  • You can optionally Save the code in the Snippy window as a snippet file. This is designed to save a temporary snippet – if you want to reopen later, you should use the Save As snippet
  • Exports or allows the user to save the code in the Snippy window (wrapped with the templated code) as a C# file

+ View add-ins Hide add-ins