Month: February 2008

Yesterday, I was proof reading chapter 11 of the book (and chapter 12, and chapter 13 – it was a long night). Reading my own text about how query expressions work led me to wonder just how far I could push the compiler in terms of understanding completely bizarre query expressions. Background Query expressions in C# 3 work by translating them into “normal” C# first, then applying normal compilation. So, for instance, a query expression of: from x in words where x.Length > 5 select x.ToUpper() … is translated into this: words.Where(x => x.Length > 5)      .Select(x => x.ToUpper()) Now, usually the source expression (words in this case) is something like a variable, … Continue reading Odd query expressions

When talking about LINQ recently, I doodled an implementation of OrderBy on a whiteboard. Now, I know the real OrderBy method has to support ThenBy which makes life slightly tougher, but let’s suppose for a moment that it didn’t. Let’s further suppose that we don’t mind O(n2) efficiency, but we do want to abide by the restriction that the sort should be stable. Here’s one implementation: public static IEnumerable<TSource> OrderBy<TSource,TKey>    (this IEnumerable<TSource> source,     Func<TSource,TKey> keySelector){    IComparer<TKey> comparer = Comparer<TKey>.Default;    List<TSource> buffer = new List<TSource>();    foreach (TSource item in source)    {        // Find out where to insert the element –        // immediately … Continue reading Implementing deferred execution, and a potential trap to avoid

I was explaining data pipelines in LINQ to Objects to a colleague yesterday, partly as the next step after explaining iterator blocks, and partly because, well, I love talking about C# 3 and LINQ. (Really, it’s becoming a serious problem. Now that I’ve finished writing the main text of my book, my brain is properly processing the stuff I’ve written about. I hadn’t planned to be blogging as actively as I have been recently – it’s just a natural result of thinking about cool things to do with LINQ. It’s great fun, but in some ways I hope it stops … Continue reading Data pipelines as a conceptual stepping stone to higher order functions

Just taking a quick break from proof-reading to post a thought I had yesterday. Visual LINQ uses ToString() to convert an expression tree’s body into readable text. In some cases it works brilliantly, reproducing the original source code exactly – but in other cases it’s far from useful. For instance, from this expression tree representation: (Convert(word.get_Chars(0)) = 113) I suspect you wouldn’t have guessed that the original code was: word[0] == ‘q’ Personally I don’t find it terrifically obvious, even though I can see how it works. Here’s a thought though – suppose the LambdaExpression class had a Source property … Continue reading LambdaExpression – source code would be nice

Critical link (in case you can’t find it): Source Code Download Update: Dmitry Lyalin has put together a screencast of Visual LINQ in action – it gives a much better idea of what it’s like than static pictures do. There’s music, but no speech – so you won’t be missing any important information if you mute it.  I was going to save this until it was rather more polished, but I’ve just started reading the first proofs of C# in Depth, so it’s unlikely I’ll have much time for coding in the near future. I’m too excited about the results … Continue reading Visual LINQ: Watch query expressions as they happen!

Last night I gave a talk about C# 3 and LINQ, organised by Iterative Training and NxtGenUG. I attempted to cover all the features of C# 3 and the basics of LINQ in about an hour and a half or so. It’s quite a brutal challenge, and obviously I wasn’t able to go into much detail about anything. It went down reasonably well, but I can’t help feeling there’s a lot of room for improvement. That said, there was one part of the talk which really did go well, and made the appropriate points effectively. I had demonstrated the following … Continue reading Human LINQ