This is the new language feature that is generating most discussions. Just like C# you can now use the var keyword when declaring variables. It has the exact same semantics, and any guideline you will find on how to use it in C# will also apply in X++.
In C# the var keyword was introduced to enable scenarios where declaring the type was impossible, near-impossible or irrelevant, like with anonymous types and generics. Writing less was naturally well received by a lot of developers, and the use of var blossomed. It is also a great topic for steering up a debate. There are lots of guidelines and opinions. They cover the entire range from one extreme: "Always use it, it makes code easier to read" to the opposite extreme: "Never use it, it makes code harder to read".
X++ does not support anonymous types or generics in AX7 - so the real need for the var keyword is not present - yet it is supported, and already heavily used. Like in C# the use of var is as strongly typed as when the type is explicitly provided.
Personally, I'm recommending using var in only two cases:
In C# the var keyword was introduced to enable scenarios where declaring the type was impossible, near-impossible or irrelevant, like with anonymous types and generics. Writing less was naturally well received by a lot of developers, and the use of var blossomed. It is also a great topic for steering up a debate. There are lots of guidelines and opinions. They cover the entire range from one extreme: "Always use it, it makes code easier to read" to the opposite extreme: "Never use it, it makes code harder to read".
X++ does not support anonymous types or generics in AX7 - so the real need for the var keyword is not present - yet it is supported, and already heavily used. Like in C# the use of var is as strongly typed as when the type is explicitly provided.
Personally, I'm recommending using var in only two cases:
When the type is obvious.
In X++ there is a lot of repetition. The var keyword can help avoid some of this clutter while making the code easier to read, without any information gets lost to the reader.
For example:
MyClass myClass = new MyClass();
In AX7 I would write:
var myClass = new MyClass();
When the type is irrelevant.
Sometimes you don't care about the type. If you don't care the reader most likely doesn't either.
For example:
ListEnumerator enumerator = myCollection.getEnumerator();
In AX7 I would write:
There are a number of X++ specific reasons to not use var (i.e. doesn't apply to C#)
In the X++ editor in Visual Studio, you can use F12 to go to the declaration of a type. However, the X++ editor is still not as smart as the X++ compiler. At the time of this writing you are losing this drill through capability when not explicitly specifying the type of the variable. The same applies for IntelliSense – when using the var keyword, IntelliSense is not available (yet).
var enumerator = myCollection.getEnumerator();
There are a number of X++ specific reasons to not use var (i.e. doesn't apply to C#)
Limited support Visual Studio.
Higher risk of runtime errors.
Just like the C# compiler, the X++ compiler will determine the type from the assignment to the variable and enforce all the same rules and restrictions.
So you might think that the use of var doesn't lead to more runtime errors. There is a catch in X++ - you should be aware of. The X++ compiler doesn't enforce any validation of method invocations on object or common. So if the X++ compiler determines the type to be object or common, then you lost your safety net. It is not always obvious.
Consider this code:
CustTable custTable = Xml2Record(xml);
custTable.someInvalidMethod(); // Compile error
Using var, the code becomes:
var custTable = Xml2Record(xml);
custTable.someInvalidMethod(); // No compile error, as Xml2Record() returns a common
