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).
