Compare compiled .NET assemblies?

Are there any good programs out there to compare to compile .NET assemblies?

For example I have HelloWorld.dll (1.0.0.0) and HelloWorld.dll (2.0.0.0), and I want to compare differences how can I do this?

I know I can use .NET Reflector and use the Assembly Diff plugin. Are there any other good tools out there to do this?

Ways to Compare .NET Assemblies suggests

Commercial:

• NDepend

Free:

• JustAssembly (only shows differences in API)
• BitDiffer (same)
• Reflector Diff Add-in (which you've already discovered, but not available anymore)

---

Existing compare tools like Beyond Compare (commercial) can do this by special configuration. Here's how to do this for Beyond Compare:

• Go to Tools → Options
• Click New.., select "Text format", click OK
• Give it a name (say, EXE, or DLL), and specify the mask as *.exe or *.dll
• Click on tab Conversion and select "External program (Unicode filenames)"
• Under "Loading", specify the path to ildasm and add %s /OUT:%t /NOBAR (i.e.: C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8 Tools\ildasm.exe %s /OUT:%t /NOBAR)
• Make sure to check disable editing.
• Click Save, then Close
• Restart BC and open two exe files to compare, it should decompile into ilasm automatically now.

You can also add syntax highlighting to this new format. I plan to send the syntax file to them so that it'll become available to share.

Two ways.

You could ILDASM and diff with classic tools.

Or you could use NDepends, which will cost for that feature.

[Piece to C# bloaters..]

I just had to compare two revisions of the same DLL, which had the same version (I needed to implement a small hotfix, and deploy the DLL in production, but I wanted to make sure that no other changes leaked into code). Ideally, I would want the Assemby Diff add-in to show me the difference, but it does not work (it thinks that I'm comparing a DLL to itself). So this is what I did:

• Created two folders to hold disassembled source files.
• Used the Reflector's Export option (from context menu) to generate source files from each DLL in the folders created in previous step.
• Used the free DiffMerge tool to compare two directories; the tools showed me the modified files and the difference.

It's a bit kludgy, but seems to work. I wish the Assembly Diff add-in worked, though.

UPDATE: The latest version of the Assembly Diff add-in is supposed to fix the issue of comparing two versions of the same assembly. Give it a try.

The tool NDepend offers many features to compare compiled .NET assemblies.

First from the NDepend Start Page click: Compare 2 versions of a code base. This will let you provide older and newer versions of your assemblies.

Then after NDepend has analyzed both older and newer assemblies, you can use the panel Search by Change. It is dedicated to browse assemblies code diff. Notice that:

• If source code is available, just right click an element and click Diff Source. In the NDepend options you can plug to NDepend any code diff tool (Visual Studio, Beyond Compare...)
• If you don't have the source code and just only the raw assemblies, there is the option Compare older and newer version disassembled with ILSpy. ILSpy v7.0 and upper versions are supported. This menu works on assembly, namespace, type and method level and you can choose to decompile to C# or IL.

Notice also in the screenshot that a CQLinq code query is generated to browse the diff.

from m in Application.Methods 
where m.CodeWasChanged() 
select new { m, m.NbLinesOfCode }

Many others default diff queries and rules are proposed by default, that will let you browse .NET code diff in a smart way.

• Types that used to be 100% covered but not anymore
• API Breaking Changes: Methods
• Avoid making complex methods even more complex
• Avoid decreasing code coverage by tests of types
• From now, all types added or refactored should respect basic quality principles
• Avoid transforming an immutable type into a mutable one
• Heuristic to find types moved from one namespace or assembly to another

Disclaimer: I am one of the developer of the tool.

One more option is LibCheck from Microsoft.

Pretty old console tool for just getting public API diff. I could not run without debugging and retargeting to a more recent .net version. However, it gave me very clear output and I am going to use it later.

Here is an article with screenshots.

Here's a thinking outside the box approach whcih works fine.

1. Dump your old and new assemblies with dnSpy, dotPeek or JustDecompile into projects.

2. Create a new Git repo and commit the old assembly code first.

3. In your local repo folder delete all the files/folders except for ".git" and paste the new assembly files.

4. Either commit the new changes and view changes on say Github or use a Git viewer like Fork. Easy code comparison for free.

Java has a nice one: https://stackoverflow.com/questions/523307/semantic-diff-utilities/