when use type inference? we can always use VAR?

Question

The type inference VAR,serves only to be recognized by the program only if he has to go to replace "int "string" etc.? If yes,would it not be better to always use VAR?

Answer 1

There are pros and cons to using the var keyword.

What are the benefits of using var

• Dont Repeat Yourself (DRY) – Redundant code should be avoided.
• Faster creation of code
• Calls for improved naming of variables – can work as a reminder for descriptive naming
• Improved readability – in some cases (where the repeated type is long and complex)
• Less code modification if you later need to change the type
• Clearer distinction of when you really want to specify the type

The disadvantages of using var

• Loss of readability – in some cases (where the type isn’t obvious)
• Changes to the type could introduce bugs which the compiler otherwise would have caught for the developer

+ Good:

• var numbers = new int[] {1, 2, 3, 4};
• var stringbuilder = new StringBuilder();
• var cars = new List();
• var orders = new Dictionary();

+/- OK with either (but prefer explicit declaration):

• int pages = 10;
• string username = “john”;
• var username = “john”;
• var order = GetOrder(orderId); // ok if the type is Order, otherwise not
• for (var x = 1; x < 10; x++)

- Bad:

• var settings = GetInboxSettings(); // not obvious at all
• var userId = GetUserId(); // ambigous, is this guid, string, int or a custom UserId object?
• Dictionary orders = new Dictionary(); // redundant

Answer 2

In MSDN, there are some guidelines. Usually, it helps readability in this cases:

1. Declaring a variable with a primitive value: var i = 0
2. Declaring an object with a constructor: var logText = new StringBuilder()
3. Inside for and foreach statements: foreach (var word in dictionary)
4. Dealing with LINQ queries.

Also, note that there's a case where var is obligatory, in the construction of anonymous types.

Answer 3

I usually opt for var and try to choose speaking variable names. But in some cases using the actual type can be very helpful:

• In some special cases it might make the code more readable to use the actual type.

• You might want to initialize a variable with null (which is an arguable practice), wich prevents the compiler from infering the type.

• Quite often, especially when coding against interfaces and abstractions, you want to explicitly use an interface or a base type as in IEnumerable<Item> items = new List<Item>()