I've been using VS2008 Team System Dev Edition since it hit MSDN, and it improves on 2005 in almost every way, although not necessarily that much. C# 3.0 and LINQ are definitely the best things about it, and Team Build in TFS is a lot better (read: usable).

As you say, though, the stuff I really want remains "H1 2008":

ADO.NET Entity Framework, which will do the things I need that LINQ to SQL doesn't;

Parallel FX, especially the Parallel LINQ which will make multi-core support a breeze;

ASP.NET 3.5 Extensions, especially the MVC Framework;

SQL 2008 and the Sync Framework, so I can stop faffing about with SQL 2000's appalling merge replication;

Windows Server 2008, although (waiting upon waiting) that'll be of even more interest when they add ASP.NET support to the Core Web Server.

There's also the vague promise of Rosario, the assertedly much-more-improved Team System, although my cup runneth over so much I haven't even downloaded the CTP for that yet.

Don't make the mistake of equating C#3's "var" keyword with Javascript's "var". The two are entirely different, even if they are (unfortunately) named the same.

The var foo = "bar" example is very simplistic. Consider the keystroke savings in:

var q = Customer c => db.Customers.Where(cust => cust.ID == c.ID).Select(new Foo(c));

versus

Expression<Function<Customer, IQueryable<Foo>>> q = ...;

It is plainly obvious that naming expressions of lambdas involving nested generic types is onerous. It is also something that shows up frequently in LINQ.

Incidentally, the var keyword is *required* for use with anonymous types. Since the identity of the type is not knowable except by the compiler itself, this allows the programmer to still write the following strongly-typed code:

// must use var, because there is no name for the type

var q = db.Customers.Select(c => new { c.LastName, c.FirstName, HalfAge = c.Age / 2 }).First();

q.LastName = "Eubanks";

// q.Age = "One"; // compiler error -- q.Age doesn't exist

// q.HalfAge = "One"; // compiler error -- q.HalfAge is strongly typed

// q = "Two"; // compiler error -- q is strongly typed

-- Keith J. Farmer [MSFT], ex-LINQ to SQL/now-Silverlight

Re: "var at the top of the class"

The compiler would be happy to tell you that:

"The contextual keyword 'var' may only appear within a local variable declaration"

I would recommend downloading the compiler and actually trying out the new features. It's easier, and more accurate, than pure speculation.

Anon, Robert: the most important thing about the var keyword in C# is that it can only be used when declaring and initializing in a single statement. So you can't say

var x;

x = 1;

You have to say

var x = 1;

which will declare x as an int for the life of the variable: you can't assign a string value to it later. As Keith says, it's not particularly useful when dealing with ints, strings and so on, and in my code I still use the type name for those. And when you're creating a new instance, it's still easier (IMO) to specify the type and let Intellisense fill in the "new" bit.

But it is necessary for the anonymous types and LINQ stuff, and it's also pretty useful when you're getting an object back from a method and you don't want to type the whole namespace-qualified class name. I really like being able to say

var cn = Server.GetConnection();

var cmd = cn.CreateCommand();

...

var dr = cmd.ExecuteReader();

It's also important to note that Intellisense knows what type the variable is and provides the methods/properties just as if you'd specified the type name.

HTH.