Empower your lambdas!

If you’ve used generic repositories, you will encounter one particular problem, matching items using dynamic property names isn’t easy. However, using generic repositories has always been a must for me, as it saves me having to write a lot of boilerplate code for saving, updating and so forth. Not long ago, I had a problem, I was fetching entities from a web service and writing them to the database and given that these entities had relationships, I couldn’t retrieve the same entity and save it twice, so I had a problem.
Whenever my code fetched the properties from the service, it had to realize if this entity had been loaded previously and instead of saving it twice, just modified the last updated time and any actual properties that may had changed. To begin with, I had a simple code on a base web service consumer class like this.

var client = ServiceUtils.CreateClient();
var request = ServiceUtils.CreateRequest(requestUrl);
var resp = client.ExecuteAsGet(request, "GET");
var allItems = JsonConvert.DeserializeObject<List<T>>(resp.Content);

This was all very nice and so far, I had a very generic approach (using DeserializeObject<T>). However, I had to check if the item had been previously fetched and one item’s own identity could be determined by one or more properties and my internal Id was meaningless on this context to determine if an object existed previously or not. So, I had to come up with another approach. I created a basic attribute and called it IdentityProperty, whenever a property would define identity of an object externally, I would annotate it with it, so I ended up with entities like this:

public class Person: Entity
    public string PassportNumber { get; set; } 
    public string SocialSecurityNumber { get; set; }

    public string Name {get; set}

This would mark all properties that defined identity on the context of web services. So far, so good, my entities now know what defines them on the domain, now I need my generic service consumer to find them on the database so I don’t get duplicates. Now, considering that all my entities fetched from a web service have a Cached and a Timeout property, ideally, I would have something like this:

foreach (var item in allItems)
    var calculatedLambda = CalculateLambdaMatchingEntity(item);
    var match = repository.FindBy(calculatedLambda);

    if (match == null) {
        item.LastCached = DateTime.Now;
        item.Timeout = cacheControl;
    else {
        var timeout = match.Cached.AddSeconds(match.Timeout);
        if (DateTime.Now &gt; timeout){
            //Update Entity using reflection
            item.LastCached = DateTime.Now;

Well, actually, this is what I have, but the good stuff is on the CalculateLambda method. The idea behind that method is to calculate a lambda to be passed to the FindBy method using the only the properties that contains the IdentityProperty attribute. So, my method looks like this:

private Expression&lt;Func&lt;T, bool&gt;&gt; CalculateLambdaMatchingEntity&lt;T&gt;(T entityToMatch)
 var properties = typeof (T).GetProperties();
 var expresionParameter = Expression.Parameter(typeof (T));
 Expression resultingFilter = null;

 foreach (var propertyInfo in properties) {
  var hasIdentityAttribute = propertyInfo.GetCustomAttributes(typeof (IdentityPropertyAttribute), false).Any();

  if (!hasIdentityAttribute)

  var propertyCall = Expression.Property(expresionParameter, propertyInfo);

  var currentValue = propertyInfo.GetValue(entityToMatch, new object[] {});
  var comparisonExpression = Expression.Constant(currentValue);

  var component = Expression.Equal(propertyCall, comparisonExpression);

  var finalExpression = Expression.Lambda(component, expresionParameter);

  if (resultingFilter == null)
   resultingFilter = finalExpression;
   resultingFilter = Expression.And(resultingFilter, finalExpression);

    return (Expression&lt;Func&lt;T, bool&gt;&gt;)resultingFilter;

Fancy code apart, what this does is just iterate trough the properties of the object and construct a lambda matching the object received as sample, so for our sample class Person, if our service retrieves a person with passport “SAMPLE” and social security number “ANOTHER”, the generated lambda would be the equivalent of issuing a query like

repository.FindBy(person =&gt; person.Passport == "SAMPLE" &amp;&amp; person.SocialSecurityNumber == "ANOTHER")

Performance you say?

If you’ve read the about section on my blog, you’ll know that I work for a company that cares about performance, so once I did this, I knew the next step was bechmarking the process. It doesn’t really matter the fact that it was for a personal project, I had to know that the performance made it a viable idea. So, I ended up doing a set of basic tests benchmarking the total time that the update foreach would take and I came up with these results:

Scenario Matching data Ticks Faster?
Lambda calculation Yes 5570318 Yes
No Lambda calculation Yes 7870450
Lambda calculation No 1780102 No
No Lambda calculation No 1660095

These are actually quite simple to explain, when no data is available, the overhead of calculating a lambda, makes it loose the edge because no items match on the query, however, when there are items matching the power of lambdas shows up, because the compiler doesn’t have to build the expression tree from an expression, but instead, it will receive a previously built tree, so it’s faster to execute. So, back into the initial title, empower your lambdas!
If you have any other point of view on these ideas, feel free to leave a comment even if you are going to prove me wrong with it because I’ve always said that nobody knows everything, so I might be very mistaken here. On the other hand, if this helps, then my job is complete here.

Leave a Reply

Your email address will not be published. Required fields are marked *