and also, a short hand method would be nice, but i don’t mind the typing, especially with VS2k8 all you have to do is type the first letter of the type after typing new and then hit enter and its auto completed.

Every programmer has their own preference.
happy coding

If you want to support this in the language, then vote for the suggestion at the Microsoft Connect site:

https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=388649

@Jonathan Allen: I should have elaborated, but what I meant by that was this is something that should be included in the language. You are absolutely right that it can’t be done now. I have recommended it to Mads at MS though, but I don’t know if it gained any traction.

@Buu Nguyen: My recommendation (if it was implemented) does not make using the type on the right-hand side an error. You could still use it, just the same as you would before (and it would have to be that way, since there would be all that legacy code to support).

First: declaring lots of (local) variables is a sign of bad coding practices, in my opinion. Second: having to know the type of a variable to be able to understand your code is a sign of bad naming practices, in my opinion.

And to those that say that this will generate more run-time errors: please read up on the subject again. There is no dynamic typing going on when using var.

So to me, it seems like a bad idea to do both, using a lot of explicit type declarations OR var’s – but if you must, use var, as it is shorter and the type information is right at your mouse pointer if you really do need it.

Explicitly typing
1) in cases of initialization by a method or function explicitly typing makes the code more clear.
2) When in need of a variable that you can’t initialize right away (although this should be rare).

Implicitly typing
1) when initializing a variable in c# the part on the right hand side of the = is more important than what is on the left. example

List names = new List {“Tony”, “Bob”, “Mike”, “Phil”};

Developers for typing say that adding var makes it less clear here because it doesn’t tell them what “names” is right away. To which I respond that is the point. You need to look past the left declaration and focus on the right which has more going on than just declaring an empty list.

2) using var with initialized variables does remove the redundancy and make code easier to read.

As Manav stated (in post # 24 above), what happens when a function’s return type changes? The change may or may not cause undesirable effects in code that is calling the function. But why take the chance? I’d also like to avoid the possibility of a future version of the compiler inferring the type of a variable differently. As stated by others, in VS, you can hover over a “var” declared variable to see its type via intellisense. There are times, however, when I am looking at code outside of VS and intellisense is not available.

It’s considerably easier to read the left hand side of the “A thing = new A()” statement than the right hand side. This is because the left hand side always starts in the same column and therefore can be easily scanned. If you start seeing “var thing = …” you have to stop and start scanning to the right to figure out what the type will be. This is an example of one of those small efforts that adds up over time that Jeff Atwood posted about yesterday.