ComponentOne's LiveLinq promises to boost the performance of Microsoft's Language Integrated Query (LINQ) operations by means of indexing LINQ queries. This doesn't mean it adds indexes to your underlying database for LINQ to SQL queries. Instead, LiveLinq is persistence-ignorant—meaning that the indexes it creates are on your data once it's been pulled into CLR memory. This, in turn, translates into increased performance for data-heavy applications, with only a minor amount of effort or coding required. In fact, at the simplest level, adding indexed query functionality is as simple as adding simple extension methods to your object collections.

In addition to providing a bevy of extension methods that enable indexing and speed up LINQ operations, LiveLinq also provides functionality called Live Views. Live Views permit the results of a LINQ query to remain actively attached to the in-memory data source or collection that was queried. This functionality is useful for data-binding scenarios within rich applications such as Silverlight or WPF applications. However, any object that you want to participate in a Live View needs to derive from an IndexableObject, so you can code your property setters to include calls to the IndexableObject's OnPropertyChanging() and OnPropertyChanged() events. And while having to derive from a different base class is a downer, seeing a Live View in action as a Data Binding source is very impressive.

Live Views coupled with indexing capabilities opens up some intriguing possibilities when it comes to scaling applications. For example, if you had an e-commerce application with a large product catalog, you could let site users just thump the database over and over again as they browsed the site. (A better option, of course, would be to use caching to avoid repetitious queries.) But with LiveLinq, you can create a middle tier that pulls in large swaths of data, indexes that data, then uses LiveView operations to keep data updated as needed. You could then query this middle-tier object as an in-memory database to reduce load on your database and increase scalability. (Taking such an approach would take some effort. But I was able to build out a proof of concept without too much effort for a project I'm currently working on.)

LiveLinq sells for $1,300 per license and is easy to install, set up, and use as it's primarily just a set of class libraries and extension methods. The LiveLinq installer also deploys a large collection of well-designed sample applications that work well with the accompanying introductory documentation to bring developers quickly up to speed on options and operations. Consequently, LiveLinq is very developer friendly. In fact, my only serious criticism of LiveLinq is the omission of examples showcasing how to work with data pulled out of LINQ to SQL and Entity Framework solutions. Instead, the samples favor examples of pulling data out of DataSets (which I consider the spawn of the devil). It does have good examples of pulling data from XML or working with collections of objects (just no LINQ to SQL and Entity Framework examples).

In putting LiveLinq through the paces with a collection of 80,000 objects that I pulled out of my database, I noticed that the performance benefits stemming from the in-memory indexes placed upon DateTime properties on my objects didn't return as large of a performance boost as I saw on other data types. Most likely, this was due to some slight differences in the DateTime precision of my objects versus that of my search criteria, and I would expect that a bit more work on my part would remedy this problem, as indexes in any solution are susceptible to mismatches like this. Otherwise, aside from a trivial annoyance with a naming convention within the LiveLinq framework (between a collection of indexes called an IndexCollection vs an indexable collection of called an IndexedCollection), I found coding with LiveLinq to be intuitive and fully capable of delivering on the performance benefits advertised.

All in all, LiveLinq has fantastic potential. It definitely delivers when it comes to indexing LINQ queries, and its Live Views functionality can be a major boon for Silverlight, WPF, and other rich applications that rely heavily upon data-binding. Likewise, when used correctly, it can help relieve significant load on databases by pulling data locally and manipulating it in-memory as needed. Consequently, I heartily recommend that anyone looking to improve performance, scalability, or leverage rich data-binding capabilities pull down a trial copy of LiveLinq and give it a whirl.

ComponentOne LiveLinq
PROS: Fully persistence-ignorant indexing capabilities that can deliver massive performance benefits for LINQ operations. Live View functionality enables compelling data-binding capabilities for Microsoft Silverlight, Windows Presentation Foundation (WPF), and other rich Microsoft .NET applications. Can be leveraged to take significant load off of databases to increase application scalability.
CONS: Although the sample applications that ship with LiveLinq are excellent, it's missing sample projects centered around LINQ to SQL and the Entity Framework. Live View functionality requires objects to derive from an IndexableObject, which impinges on persistence ignorance and might conflict with other developer requirements or needs.
RATING:4 out of 5
PRICE: $1,300 per license
RECOMMENDATION: LiveLinq seems to be a solution that ComponentOne has largely forgotten and that few people know about. It has some limitations and won't be immediately beneficial to every kind of application or solution. It provides some compelling capabilities, performance benefits, and scalability options that shouldn't be ignored. Therefore, organizations looking to improve LINQ performance, bolster scalability, or increase data-binding capabilities for rich applications should definitely give LiveLinq a test drive. CONTACT: 1-800-858.2739 •412.681.4343 •http://www.componentone.com