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-listopt ) => 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();
p
=> p.Equals("Sleepless")); expands to the
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 Main(string[] args)
{
0.Convert();
Console.Read();
}
private
static void Convert(this double temp)
{
double num = (1 * temp) + 32;
Console.WriteLine(num);
}
.method
private hidebysig static void Convert(float64 temp) cil managed
{
.custom instance void [System.Core]System.Runtime.CompilerServices.ExtensionAttribute::.ctor()
= ( 01 00 00 00 )
// Code size 29 (0x1d)
.maxstack 2
.locals init ([0] float64 tempF)
IL_0000: ldc.r8 1.
IL_0009: ldarg.0
IL_000a: mul
IL_000b: ldc.r8 32.
IL_0014: add
IL_0015: stloc.0
IL_0016: ldloc.0
IL_0017: call void [mscorlib]System.Console::WriteLine(float64)
IL_001c: ret
} //
end of method Program::Convert |
.method
private hidebysig static void
Main
(string[] args) cil managed
{
.entrypoint
// Code size 23 (0x17)
.maxstack 1
.locals init ([0] float64 temperature)
IL_0000: ldc.r8 0.0
IL_0009: stloc.0
IL_000a: ldloc.0
IL_000b: call void
VS.NET2008Features.Program::Convert(float64)
IL_0010: call int32
[mscorlib]System.Console::Read()
IL_0015: pop
IL_0016: ret
} //
end of method Program::Main |
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.
