This is really a readability issue with your code.
My personal preference is to only ever use "var" for anonymous types (indeed, if you wish to use anonymous types at all, you'll need to use var), and these mostly come from LINQ queries. In these cases, you have no choice but to use var if your query is projecting into a new (implicit & anonymous) type.
However, C# 3.0 will happily let you use var anywhere you like, outside of LINQ and anonymous types, for example:
var myint = 0;
var mystring = "";
is perfectly valid, and myint and mystring will be strongly-typed by the inferred values used to initialize them. (thus, myint is a System.Int32 and mystring is a System.String). Of course, it's fairly obvious when looking at the values used to initialize the variables what types they will be implicitly typed to, however, I think it's even better for code readability if the above were written as:
int myint = 0;
string mystring = "";
since you can see immediately at a glance exactly which type those variables are.
Consider this somewhat confusing scenario:
var aaa = 0;
double bbb = 0;
Perfectly valid code (if a little unconventional) but in the above, I know that bbb is a double, despite the initializing value appearing to be an int, but aaa will definitely not be a double, but rather an int.