I have been working on little tool to simplify my life and perhaps yours as developer as well. It is basically a command line tool that allows you to execute queries on your compiled .NET code base. The main purpose is to find out how big the impact of an api change would be if you changed this or that.  Now you can do high level operations like

• Diff public types for breaking changes.
• Who uses a method?
• Who uses a type?
• Who uses implements an interface?
• Who references me?
• What format has the binary  (32/64, Managed C++, Pure IL, Unmanaged)?
• Search for all event subscribers and unsubscribers.
  • A unique feature is to check for event subscription imbalances. Forgotten event subscriptions are the 90% cause of managed memory leaks. It is done at a per class level. If one class does subscribe to one event more often than it does unsubscribe it is treated as possible event subscription imbalance.
• Another unique ability is to search for users of string literals which allows you to track users of a string constant which is not possible otherwise.
• For incremental builds the ShowRebuildTargets command can be used to identify the dependant targets that need a rebuild after you did compile one assembly. It has some heuristics in place to determine the impact of breaking changes and finds out which targets need to be recompiled as well.
• It has a ton of other features and a an API to access these things programmatically so you can build upon these simple queries create even better tools. Perhaps we get a Visual Studio plug in?

You can download it from CodePlex here. It works via XCopy deployment. Simply let it run and check the command line help out.

The best feature in my opinion is that the output of nearly all commands can be piped to Excel for further analysis. Since it does read also the pdbs it can show you the source file name and line number as well for all matches.

The following picture shows the output of a –WhousesType query. The following command checks where type from BaseLibraryV1.dll are used inside DependantLibV1.dll. All matches are printed out with the reason and matching item along with file and line number. There is even a hyper link to the match which will open Visual Studio.

ApiChange -whousestype "*" BaseLibraryV1.dll -in DependantLibV1.dll –excel

The "*” is the actual query which means all types. The syntax is the same like in C# just that placeholders are allowed ;-). More info's can be found at the Codeplex Documentation.

The tool was developed in a TDD style manner which means that it is heavily tested and already used by a quite large user base inside the company I do work for. Luckily for you I got the permission to make it public so you take advantage of it.

It is fully instrumented with tracing. If you find bugs simply add the –trace command line switch to find out what is failing and send me the output.

How is it done?

Your first guess might be that it uses reflection. Wrong. It is based on Mono Cecil a free IL parser with a fantastic API to access all internals of a managed assembly. The speed is awesome and to make it even faster I did make the tool heavily multi threaded. The query above did execute in 1.8s with the Excel output. On a rather slow machine I can analyze over 1500 assemblies in less than 40s with a very low memory consumption. The true power of Mono Cecil is that I can load an assembly like any other data file. I have no problems unloading a file but if I would have used reflection I would need to unload a whole AppDomain just to get rid of one assembly in my memory.

Just to give you a glimpse how ApiChange.Api.dll can be used I show you one of the unit tests:

        public void Can_Find_GenericMethodInvocations_With_Type_Parameters()

        {

            // 1. Create an aggregator to collect our matches

            UsageQueryAggregator agg = new UsageQueryAggregator();

            // 2. This is the type we want to search for. Load it via the type query

            var decimalType = TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.Decimal");

            // 3. register the type query which searches for uses of the Decimal type

            new WhoUsesType(agg, decimalType);

            // 4. Search for all users of the Decimal type in the DependandLibV1Assembly

            agg.Analyze(TestConstants.DependandLibV1Assembly);

            // Extract matches and assert

            Assert.AreEqual(2, agg.MethodMatches.Count, "Method match count");

            Assert.AreEqual("UseGenericMethod", agg.MethodMatches[0].Match.Name);

            Assert.AreEqual("UseGenericMethod", agg.MethodMatches[1].Match.Name);

        }

Many thanks go from here to Jb Evian for the creation of Mono.Cecil. Without this fantastic piece of code it would have been much much harder. There are other options around like the Common Compiler Infrastructure  Metadata Api which should do the same thing but it was not a real option since the Microsoft reader did fail on even simple assemblies (at least in September 2009 this was the case). Besides this I found the CCI Apis much harder to use. The only real competitor was Reflector which does support many things but does not let me access his cool high level analyze commands. So I decided to dig into the IL specs and as a result you can query your compiled binaries from the command line or programmatically.

The best thing is you try it out for yourself and give me some feedback what you miss. If you want to contribute or have a cool idea what should be added drop me a mail at A Kraus1@___No [email protected]. There is much more inside the tool I did not talk about it (yet).