Extending Sitecore ContentSearch with the IQueryable interface

The decision to implement a LINQ provider for the new Sitecore 7 content search is truely clever as the LINQ syntax allows a developer to do a whole lot with very few lines of code in a fairly fluent semantical form. However once your query grows more advanced the lines of endless lambda expressions tends to build up and before you know it your query has evolved into something that reads less like a concise statement and more like a novel of epic proprotions.

The following query is one such example.

String contentRootId = Sitecore.ItemIDs.ContentRoot
   .ToShortID().ToString().ToLowerInvariant();
String baseTemplateId = templateId
   .ToShortID().ToString().ToLowerInvariant();

var query = context.GetQueryable()
   .Where(item => item["_path"].Contains(contentRootId))
   .Where(item => item["_language"].Equals(Sitecore.Context.Language.Name))
   .Where(item => item["_latestversion"].Equals("1"))
   .Where(item => item["_basetemplates"].Contains(baseTemplateId));

Amazingly enough the query really doesn’t do all that much. It simply retrieves the latest version of items located beneath the content root in the current context language that inherits from the specified template.

Now the above query isn’t all that bad and of course you can read through it and so can anyone else who has to work with the code at a later date but it sure would be nice if it was a bit easier to read and more intention revealing.

Well to do that we can start by looking at some of the common methods in the LINQ library and in particular at how the Where method works. If we examine it more closely it turns out to be nothing more than an extension method to the Queryable class that acts on the Queryable object that it extends by applying the expression that it receives through its parameters to the query and returns a new Queryable object through the IQueryable interface.

This is in essence the way that most of the LINQ methods work and the way the chainable query syntax is achieved.

So if the Where method is simply an extension method that accepts an expression it is also possible to create our own extension method which instead of recieving an external expression parameter actually encapsulate a prebuilt expression to hide some of the irrelevant implementation details and make the method more intention revealing to increase readability.

With any luck we would end up with something that reads more like the following query.

var query = context.GetQueryable()
            .IsContentItem()
            .IsContextLanguage()
            .IsLatestVersion()
            .HasBaseTemplate(templateId);

So how do we actually write these extension methods? Well they really are simple to write. Here is the IsContentItem method.

public static IQueryable IsContentItem(this IQueryable query)
{
  String id = Sitecore.ItemIDs.ContentRoot.ToShortID().ToString().ToLowerInvariant();
  
  return query.Where(item => item["_path"].Contains(id));
}    

Now we have a way of creating really short intention revealing methods that are a lot easier to read and the best part is that since they are self-contained the extension methods can be reused which means that we don’t have to rewrite everything from scratch every time.

Here are the rest of the methods mentioned above.

public static IQueryable IsContextLanguage(this IQueryable query)
{
  return query.Where(item => item["_language"].Equals(Sitecore.Context.Language.Name));
}

public static IQueryable IsLatestVersion(this IQueryable query)
{
  return query.Where(item => item["_latestversion"].Equals("1"));
}

public static IQueryable HasBaseTemplate(this IQueryable query, ID templateId)
{
  String id = templateId.ToShortID().ToString().ToLowerInvariant();

  return query.Where(item => item["_basetemplates"].Contains(id));
}

Please note that the field _basetemplates isn’t available in the Sitecore index per default but as luck would have it my truely clever and talented colleague Uli Weltersbach has written a blog post about how to add this field to the index Indexing base templates – Sitecore 7 Content Search

Also if you are interested in reading more about how you can extend the LINQ syntax and work with IQueryable and expression trees I highly recommend the blog post Giving Clarity to LINQ Queries by Extending Expressions by Edward Charbeneau.