Proving a Point with LINQ (or, the Longest Type Names in the .NET Framework)

I will often take a few moments during a presentation to get a chuckle by bringing up the SharedConnectionWorkflowCommitWorkBatchService.  Due to the sheer length of the type name, it's sure to bring a smile or two in one of my otherwise snore-inducing presentation.

The other day, while reviewing a deck for a colleague I brought up that he should mention this type, and that it usually gets a laugh from a developer audience.  He then asked, "Is that really the longest type name in the framework?"  My response, "Well, I'm not really sure, I bet you could do some LINQ magic in order to figure it out." 

Well, sitting on the bus this morning with some traffic time to spare (and needing to work on my LINQ skills a bit), put together some code.  My goal was to go through all of the types, calculate their length and figure out which one was the longest named type.  You can replicate this, create a new console application, right click to add references, and select all the references you want to add into this comparison.  I added all of the system.* assemblies, PresentationFramework, PresentationCore and WindowBase.  You could do even more by selecting everything in the reference dialog.

The thing that appeals to me about LINQ is really that i can just write a query, I don't have to worry about looping through a number of times.  I also like the fact I can develop by refining, that is, I can get a collection back, tweak the query to shape it, take that new collection and query against that.

Let's first look at what I started with:

 var orderedTypeListing =
       (from assembly in AppDomain.CurrentDomain.GetAssemblies()
        select assembly.GetExportedTypes());

This ends up returning an object of type IEnumerable<List<Type>>, which doesn't quite get me to what I want.

I use the Aggregate extension method to operate on this and create an entire list of all the types contained (think of this as flattening the tree by one level, or only returning the leaf nodes in the tree).  With the Aggregate method, I need to provide the operation to do the accumulation.

 var orderedTypeListing =
   (from assembly in AppDomain.CurrentDomain.GetAssemblies()
     select assembly.GetExportedTypes()).Aggregate(
           (x, y) =>
           { return x.Union(y).ToArray(); }
        )

The only weirdness here is that I have to use ToArray(); since Aggregate returns T[], rather than IEnumerable<T>.

Now I add a little bit of code to do some ordering.  I like the ordering syntax since I just provide a way to get the value I want to sort by.  Remember to use OrderByDescending in order to get the right ordering.

Our query near looks like this:

 var orderedTypeListing =
   (from assembly in AppDomain.CurrentDomain.GetAssemblies()
     select assembly.GetExportedTypes()).Aggregate(
           (x, y) =>
           { return x.Union(y).ToArray(); }
        ).OrderByDescending(
            (x) =>
            { return x.Name.Length; }
        );

So this returns a list, ordered by the length of the name.

I could just grab the first one off the list, and I'd be done, but I'd like to see the 100 longest names, just in case I'm wrong about our friend SharedConnectionWorkflowCommitWorkBatchService.   To do this, I'll say I want to take 100 off the top of the list and print those out. 

 int count = 1;
orderedTypeListing.Take(100).ToList().ForEach
(
    x => 
    Console.WriteLine("{0}: {1}, {3} ({2})", 
    count++, 
    x.Name.Length, 
    x.Assembly.FullName.Split(",".ToCharArray())[1], 
    x.Name)
    );

This will pretty print the top 100 longest names (these are at the bottom of the post).

Next, i thought, I'd really like to see a histogram of the sizes.  To do that, I need to group by data.  The Group() extension method, just like the order method, allows me to pass in the value by which I want to group (and that can be computed, say a hash).  It also returns an IGrouping that lets me see the key (in my case, the size of the key) and the IEnumerable itself.

 var groupedTypeListing = orderedTypeListing.GroupBy(
    t => 
    { return t.Name.Length; }
    );
groupedTypeListing.ToList().ForEach(
    x => 
        Console.WriteLine("{0} : {1}", x.Key, x.Count())
        );

Finally, I thought I'd see just how many types were included in each version of the framework, and prove that I can group by anything, including manipulating the string on the assembly's full name.

 var groupedVersionListing = orderedTypeListing.GroupBy(
    t => 
    { return t.Assembly.FullName.Split(",".ToCharArray())[1]; }
    );
groupedVersionListing.ToList().ForEach(
    x => 
        Console.WriteLine("{0} : {1}", x.Key, x.Count()
        )
);

This has now let me retrieve a lot of interesting data (interesting at least to me :-) ) that I was able to write with a pretty simple query syntax and do some somewhat sophisticated things (grouping, etc).

It turns out that our friend SharedConnectionWorkflowCommitWorkBatchService is only number 16 on my list.  The real honor goes to:

AttachedPropertyBrowsableWhenAttributePresentAttribute, with 53 characters.

Histogram of Type Name Sizes

Top 100 Longest Type Names