@var madness

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.

@var madness

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.

@var madness

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