.NET Assembly Diff / Compare Tool - What's available? [closed]

Answer 1

I made a small tool specifically for comparing Assemblies in a certain way. I had two assemblies which were basically the same except the IL in the methods was slightly different and one had some NOPs spread throughout. The C# code was almost identical for them, but the IL was clearly quite different. I tried using ILDasm and comparing the generated output with TortoiseMerge/WinDiff, but it had so many false differences that it was useless. The NOPs really messed with the output since it changed branch addresses and such and basically produced a difference on every line of each method.

So, I built a small tool called ILDump. It's BSD licensed. It is capable of trimming out NOPs, using "smart" label renaming so that code that is the same, but shifted by a NOP, it won't be detected as a difference by Diff programs, and it also only prints out significant labels(ie, ones that are branched/switched to). It also can sort methods so that two assemblies that were "created" in a different way won't be caught as a difference.

It's definitely not perfect, it doesn't handle any thing but dumping out each method's IL, and there is no hope of round tripping. The reason I created it was to make reading a method's IL easier(it's smart labeling makes it significantly easier to track branches), and so that I could run it through a program like TortoiseMerge or WinDiff and it not say there is a difference on every line of code.

Answer 2

ILSpy can decompile an assmembly out to a tidy directory structure. Do this for each of your assemblies and you can use a diff tool of your choice to see what has changed.

Answer 3

Try these:

• NDepend
• Framework Design Studio

Answer 4

The diff addin for reflector is great! Ive been using it for years.

Answer 5

The tool NDepend offers many features to handle .NET code diff.

The panel Search by Change is dedicated to browse assemblies code diff:

---

Many code rules that constraint diff and evolution are proposed. They can be a good start to write your own ones or adapt them to your needs. For example look at the rule:

Types that used to be 100% covered but not anymore

// <Name>Types that used to be 100% covered but not anymore</Name>
warnif count > 0
from t in JustMyCode.Types where 
   t.IsPresentInBothBuilds() &&
   t.OlderVersion().PercentageCoverage == 100 &&
   t.PercentageCoverage < 100
let culpritMethods = t.Methods.Where(m => m.PercentageCoverage < 100)
select new {t, t.PercentageCoverage, culpritMethods }

or also:

• 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

---

To get started with NDepend compare capabilities, have a look at the documentation:

• Advanced Code Diff from within Visual Studio: explains how to use the NDepend build comparison features, in the context of Visual Studio and Visual NDepend standalone UI.

• Reporting Code Diff: explains how to use the NDepend build comparison features, in the context of reporting.

Disclaimer: I work for NDepend

Answer 6

This is sort of a duplicated question, to this one.

As mentioned in the other one, there's a free & open source tool called BitDiffer. It's amazing, it can compare entire builds or single DLLs and it shows the namespace hierarchy to easily find what changed.