Rephrased the use of var (#250)

Author: dennisdoomen

_rules/1520.md

@@ -1,22 +1,40 @@
 ---
 rule_id: 1520
 rule_category: maintainability
-title: Only use `var` when the type is very obvious
+title: Only use `var` when the type is obvious or unimportant
 severity: 1
 ---
-Only use `var` as the result of a LINQ query, or if the type is very obvious from the same statement and using it would improve readability. So don't
+Only use `var` as the result of a LINQ query, if the type is very obvious from the same statement, or when it's really not important.
 
-	// what type? int? uint? float?
-	var item = 3;
+	// Debatable: Did the author intend to use a long here? 
+	var indexInSpan = 0;
 
-	// Not obvious what base-class or interface to expect.
-	// Also difficult to refactor if you can't search for the class.
-	var myfoo = MyFactoryMethod.Create("arg");
+	// Bad: What does this return? An IEnumerable<T>? IEqueryable<T>? What about deferred execution?
+	var results = RunSearchQuery(searchColumnsSql);
+
+	// Bad: If the type is so important you have to put it in the name of the variable, use an explicit type.
+	var valueString = GetDisplayValueOf(context);
+
+	// Debatable: DbType? SqlDbType? OracleDbType? Might be good to know.
+	var dataType = row.GetColumnType(columnIndex);
+
+Even for the debatable cases, making the type explicit will avoid another round of code review comments.
 
 Instead, use `var` like this:
 
-	var query = from order in orders where order.Items > 10 and order.TotalValue > 1000;
-	var repository = new RepositoryFactory.Get();
-	var list = new ReadOnlyCollection();
+	// Good
+	var query = 
+		from order in orders 
+		where order.Items > 10 and 
+		order.TotalValue > 1000;
+
+    // Good: In most cases, it's clear that we're returning a User. Although it may be useful to know if it's a domain entity or an abstraction.
+	var user = new UserFactory.Get();
+
+	// Good: Nothing to clarify here
+	var list = new ReadOnlyCollection(); 
+	
+	// Good enough: We can safely assume it's a string
+	var displayValue = GetDisplayValueOf(context);
 
-In all of three above examples it is clear what type to expect. For a more detailed rationale about the advantages and disadvantages of using `var`, read Eric Lippert's [Uses and misuses of implicit typing](https://docs.microsoft.com/en-us/archive/blogs/ericlippert/uses-and-misuses-of-implicit-typing).
+The consequence of this guideline is that you can't use tooling to determine whether `var` is warranted. It all depends on the context.