Adnan Masood's Weblog! عدنان مسعود

Visual Studio 2008 VHD makes life a lot easier if you want to explore the upcfeature-set of  C# 3.0 compiler. Make sure to get the differencing image Visual Studio Code Name Orcas Base Image else you’d be getting the following error.

"OrcasBeta2_VSTS" could not be started because a disk-related error occurred.

Feeling bad for fellow .netters (Yes Ben, its you) who had to clean install the beta2 upgrade from beta1. For me, it was plugging in the new machine :) VM Rocks..errr...I meant virtual PC VM, not the other VM.

Anyhow, support for lambda expressions is one of the gems in C# 3.0, as defined in the C# 3.0 Language Specification

lambda-expression:
(   lambda-parameter-list_opt   )   =>   lambda-expression-body
implicitly-typed-lambda-parameter   =>   lambda-expression-body

This is essentially the same thing you’d do in CLisp, the function definition, application and recursion, all in quite elegant way. Therefore, the implication inherently defines the method without any explicit declaration. So you can say

x => x + 1 which translates to a function that takes one argument, c, and returns the value x + 1.

A less trivial example is as follows.

List<string> XFilesEpisodes = new List<string>();
XFilesEpisodes.Add("Little Green Men");
XFilesEpisodes.Add("The Host");
XFilesEpisodes.Add("Blood");
XFilesEpisodes.Add("Sleepless");
XFilesEpisodes.Add("Duane Barry");
string episodeMatch = XFilesEpisodes.Find(p => p.Equals("Sleepless"));
Console.WriteLine(episodeMatch);
Console.Read();

 string episodeMatch = XFilesEpisodes.Find(delegate(string name) {
                            return XFilesEpisodes.Equals("Sleepless");
                        });

The lambda methods evaulated within closures; these anonymous delegated blocks are not called closures because their understanding would give closure to your intellectual feat but because they can access the local members. As defined on precious wikipedia (since I can never find my PL book handy), a closure is a function that is evaluated in an environment containing one or more bound variables. When called, the function can access these variables.

Now on the IL level, this can be seen as a static predicate class of anonymous delegate (hence the expansion)

.field private static class [mscorlib]System.Predicate`1<string> '<>9__CachedAnonymousMethodDelegate1'

.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )

It is defined as anonymous delegate in the general metadata and further performs a string comparison with virtual call (in bold below). 

.method private hidebysig static bool  '< Main>b__0'(string p) cil managed
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
  // Code size       12 (0xc)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldstr      "Sleepless"
  IL_0006:  callvirt   instance bool [mscorlib]System.String::Equals(string)
  IL_000b:  ret
} // end of method Program::'< Main>b__0'

The Main method is as follows which shows the generic list of items and then the actual call to CachedAnonymousMethodDelegate.
 
.method private hidebysig static void  Main (string[] args) cil managed
{
  .entrypoint
  // Code size       110 (0x6e)
  .maxstack  4
  .locals init ([0] class [mscorlib]System.Collections.Generic.List`1<string> XFilesEpisodes,
           [1] string episodeMatch)
  IL_0000:  newobj     instance void class [mscorlib]System.Collections.Generic.List`1<string>::.ctor()

.......

  IL_003e:  ldsfld     class [mscorlib]System.Predicate`1<string> VS.NET2008Features.Program::'<>9__CachedAnonymousMethodDelegate1'
  IL_0043:  brtrue.s   IL_0056
  IL_0045:  ldnull
  IL_0046:  ldftn      bool VS.NET2008Features.Program::'<Main>b__0'(string)
  IL_004c:  newobj     instance void class [mscorlib]System.Predicate`1<string>::.ctor(object,

                                                                                       native int)
 IL_0051:  stsfld     class [mscorlib]System.Predicate`1<string> VS.NET2008Features.Program::'<>9__CachedAnonymousMethodDelegate1'

  IL_0056:  ldsfld     class [mscorlib]System.Predicate`1<string> VS.NET2008Features.Program::'<>9__CachedAnonymousMethodDelegate1'

  IL_005b:  callvirt   instance !0 class [mscorlib]System.Collections.Generic.List`1<string>::Find(class [mscorlib]System.Predicate`1<!0>)

  IL_0060:  stloc.1

  IL_0061:  ldloc.1

  IL_0062:  call       void [mscorlib]System.Console::WriteLine(string)

  IL_0067:  call       int32 [mscorlib]System.Console::Read()

  IL_006c:  pop

  IL_006d:  ret

} // end of method Program::Main

The extension methods are a very powerful feature. Think of them as highly sophisticated version of poor man’s global overrides. For instance, in the example below I’d convert all the temperature by “extending” the method on the double type which does not define a Convert method.

namespace VS.NET2008Features
{
   static class Program
   {
       static void Main(string[] args)
       {
           double temperature = 0;
           temperature.Convert();
           Console.Read();
       }

       static void Convert(this double temp)
       {
           double tempF = (9/5)* temp +32; // 9/5.0 not done on purpose.
           Console.WriteLine(tempF);
       }
   }

}

For a simple program like this, the underlying IL and reflector code looks quite interesting. First of all, note the clever IL as it will evaluate the 9/5 as 1 (integer value) since it is not a double calculation (9/5.0 would have been). Also, the extension attribute is added and redirection to this new extended method is done at the IL level. Clever eh?
 

private static void Convert(this double temp)
{
    double num = (1 * temp) + 32;
    Console.WriteLine(num);
}

The extension method is depicted here by setting the extension attribute in the CLR. The call to the Convert gets translated and redirected to VS.NET2008Features.Program::Convert(float64)

Scott Guthrie defines it best, from both developer and framework architect prospective. And till then, I'm waiting for Jeffrey Richter's addendum to CLR via C# which would discuss the C# 3.0 enhancements.