Clicky

Using let in LINQ to Objects - Stuart Leeks - Site Home - MSDN Blogs

Stuart Leeks

Stuart Leeks - Application Development Consultant

Using let in LINQ to Objects

Using let in LINQ to Objects

Rate This
  • Comments 9

I've been delving into LINQ to Objects recently (and enjoying it), but had missed the 'let' keyword. A colleague Rupert Benbrook(http://phazed.com) and I had been chatting about how to solve a particular issue using LINQ to Objects and he sent me a follow-up email with some code that used the 'let' keyword and I thought I'd take a closer look and see what happens under the covers.

To take a simple example, suppose we have int[] values. We could write the following query to double all the values

var query = from i in values
             select 2 * i;

With the let keyword, this could be rewritten as

var query = from i in values
        let doublei = 2 * i
        select doublei;

I'll give a slightly more interesting example in a moment, but this simple example lets us easily look at what actually gets generated. After firing up Reflector, it seems that the compiler treats the code above as though we'd typed

var query = from temp in
        (
            from i in values
            select new { i, doublei = 2 * i }
        )
        select temp.doublei;

So each time you add a let statement into your query, the compiler creates a new subquery that returns an anonymous type composed of the original value plus the new value specified by the let.

For a more interesting example of this, suppose we have IEnumerable<FileSystemInfo> fileSystemInfos, and that we want to pick out the files (i.e. ignore directories) where the size is under 1000 Bytes. We could use the following query

var query = from fileSystemInfo in fileSystemInfos
            where fileSystemInfo is FileInfo && ((FileInfo)fileSystemInfo).Length < 1000
            select (FileInfo) fileSystemInfo;

This code requires the cast to FileInfo in order to access the Length property, and again to ensure that we return the correct type in the query. Using let, we can perform the cast in a single place

var query = from fileSystemInfo in fileSystemInfos
        where fileSystemInfo is FileInfo
        let fileInfo = (FileInfo)fileSystemInfo
        where fileInfo.Length < 1000
        select fileInfo;

I think that this version is probably more readable, and if we had more constraints in the where clause that needed the FileInfo rather than FileSystemInfo then the let version would show a bigger difference. Again, the compiler seems to treat the above query as though it was written as

var query = from temp in
        (
            from fileSystemInfo in fileSystemInfos
            where fileSystemInfo is FileInfo
            select new { fileSystemInfo, fileInfo = (FileInfo)fileSystemInfo }
        )
        where temp.fileInfo.Length < 1000
        select temp.fileInfo;

Having used LINQ to Objects a reasonable amount, I found it interesting to come across a new keyword and was curious to find out how it works - hopefully this post gives an explanation!

  • In my previous post , I looked at what the compiler generates when you use the let keyword in LINQ to

  • Just a quick thought, but your query could be more efficient like this:

    var query = from fileSystemInfo in fileSystemInfos

           let fileInfo = fileSystemInfo as FileInfo

           where fileInfo != null && fileInfo.Length < 1000

           select fileInfo;

    The query seems simpler and there's only a single Where clause....

  • Yes, nice catch - using 'as' works really nicely here

  • This is a follow-up to my two previous posts on the let keyword Using let in LINQ to Objects Using let

  • And why not simply

       from fileInfo in fileSystemInfos.OfType<FileInfo>

              where fileInfo.Length < 1000

              select fileInfo;

    or, as I prefer:

       fileSystemInfos.OfType<FileInfo>.Where(fi => fi.Length<1000);

  • Hi Seth,

    I was looking for an example to talk about the let keyword, but I agree that the OfType method is a good fit here - thanks for calling it out.

    For simple queries I also like the conciseness or the extension method approach, and it works well with Single/First as well :-)

  • Leave a Comment

       Name

       Comment

  • Nice article  Stuartle.

Page 1 of 1 (9 items)
Leave a Comment
  • Please add 1 and 4 and type the answer here:
  • Post