Frequently Asked Questions

Answers to some common questions and issues can be found below:

Some assemblies appear with an error icon and there are error messages in the logfile. What causes this?

The most likely cause is assembly references. Make sure that all assemblies referenced by the assemblies you are comparing are available to BitDiffer, either in the same directory or in the GAC. This includes all references – for example, the .NET framework itself. You will not be able to analyze a .NET 1.1 assembly, for example, if you do not have the .NET 1.1 framework installed.

Another possible cause is version conflict issues. Try selecting “High” isolation level in the Configuration options.

I renamed a method, but it is displayed as a method removed and a new method added. Why is it displayed this way?

BitDiffer uses all possible information to correlate items across assemblies – in most cases, it must rely on the name of the method, class, enum, etc., in order to tie them together. In short, there is no sure way for BitDiffer to distinguish between a method that was renamed vs. one that was removed and another added. Some hints can be used to make an intelligent guess, but nothing is foolproof.

Future versions of BitDiffer will potentially provide an attribute that you can mark your items with to uniquely identify them across different builds of your assemblies.

Why do items appear in grey text in the main comparison window?

Normally, if an item does not match your current View Filter, it will not appear in the main view. However, if that item is a parent item of something that does match your view filter, the item is displayed to maintain consistency in the tree view. In order to identify that this item does not match your current filter criteria, it is shown in dimmed text.

For example, if you type “Foo” in the text filter window and you have a method named “Foo”, it will be displayed. The class “Bar” in which “Foo” resides will also be displayed, but it will be in grey text because “Bar” does not match your text filter.

How are breaking changes identified?

A breaking change is defined as a declaration or accessibility change to any publicly visible item.

For example, a generic method which adds a new restriction to it’s generic type parameter is a breaking change. In another example, a public property which is removed or becomes protected is also considered a breaking change.

Implementation changes and attribute changes are not considered breaking changes even on publicly visible items.

A breaking change is shown in red text in the main comparison view and assemblies which contain breaking changes are shown in red text in the assembly list window.

My assembly has an AssemblyVersionAttribute but it does not appear in the list of attributes in the comparison window. Why not?

The AssemblyVersionAttribute is actually a special compiler directive which is intercepted and replaced with an embedded version number in the assembly metadata. There is not such attribute compiled into the resulting assembly.

You can still examine the assembly version (and changes to it) by inspecting the “Version” item in the main comparison view.

What are these methods in my class that start with “<>”?

These are anonymous methods. The compiler dynamically creates these methods (and nested classes, where needed) to implement anonymous delegates in your code. Notice that these are marked with the CompilerGeneratedAttribute.

How does BitDiffer handle obfuscation?

If you are using a 3rd party library which is obfuscated, the public-facing interface should still be “in the clear” and BitDiffer can still analyze and detect changes in it. These are, in fact, the changes which are probably the most relevant to your work.

If, however, you are trying to analyze changes in an closed system which has been entirely obfuscated, you may not be as successful in extracting useful information from the analysis. Obfuscation intentionally removes meaning from the metadata and that information is permanently lost.

Having said that, depending on the obfuscation algorithm used, you may still be able to at least detect the presence of changes if not their impact. Some algorithms however, completely randomize names on every pass and therefore a comparison analysis is not possible.