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