C# in Depth

330 CHAPTER 12 LINQ beyond collections}}public object Execute(Expression expression){Logger.Log(this, expression);return null;}There’s even less to talk about in terms of the implementation of FakeQueryProviderthan there was for FakeQuery. The CreateQuery methods do no real processing but actas factory methods for FakeQuery. The Execute method overloads just return emptyresults after logging the call. This is where a lot of analysis would normally be done, alongwith the actual call to the web service, database, or whatever the target platform is.Even though we’ve done no real work, when we start to use FakeQuery as thesource in a query expression interesting things start to happen. I’ve already let sliphow we are able to write query expressions without explicitly writing methods to handlethe standard query operators: it’s all about extension methods, this time the onesin the Queryable class.12.2.3 Gluing expressions together: the Queryable extension methodsJust as the Enumerable type contains extension methods on IEnumerable to implementthe LINQ standard query operators, the Queryable type contains extensionmethods on IQueryable. There are two big differences between the implementationsin Enumerable and those in Queryable.First, the Enumerable methods all use delegates as their parameters—the Selectmethod takes a Func, for example. That’s fine for in-memorymanipulation, but for LINQ providers that execute the query elsewhere, we need a formatwe can examine more closely—expression trees. For example, the correspondingoverload of Select in Queryable takes a parameter of type Expression. The compiler doesn’t mind at all—after query translation, it hasa lambda expression that it needs to pass as a parameter to the method, and lambdaexpressions can be converted to either delegate instances or expression trees.This is the reason that LINQ to SQL is able to work so seamlessly. The four key elementsinvolved are all new features of C# 3: lambda expressions, the translation ofquery expressions into “normal” expressions that use lambda expressions, extensionmethods, and expression trees. Without all four, there would be problems. If queryexpressions were always translated into delegates, for instance, they couldn’t be usedwith a provider such as LINQ to SQL, which requires expression trees. Figure 12.3shows the two paths taken by query expressions; they differ only in what interfacestheir data source implements.Notice how in figure 12.3 the early parts of the compilation process are independentof the data source. The same query expression is used, and it’s translated in exactly thesame way. It’s only when the compiler looks at the translated query to find the appropriateSelect and Where methods to use that the data source is truly important. At thatLicensed to Rhona Hadida