X++ in AX7: The var keyword

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:

  1. 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();   

  2. 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:
    var enumerator = myCollection.getEnumerator();   

 There are a number of X++ specific reasons to not use var (i.e. doesn't apply to C#)

  1. Limited support Visual Studio.
    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).


  2. 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  



Comments (9)

  1. Hi Alex.    

    var custTable = Xml2Record(xml);

    is identical to

    common custTable = Xml2Record(xml);

    So IntelliSense will only show methods for common.  

    To get CustTable you could write:

    var custTable = Xml2Record(xml) as CustTable;

    Which has some additional benefits – like custTable being null if Xml2Record(xml) returns an incompatible type, like VendTable.

  2. Alex says:

    So I assume that if you do var custTable = Xml2Record(xml); that intellisense won't work for custTable.[whatever methods] correct?

  3. Hi Logger,

    The reference will be to MyClass.  

    To verify I created this class:

    class MyClass2


       void test()


           var x = new MyClass();



    And as expected, cross reference picked up two references to MyClass:

    /Classes/MyClass2/Methods/test – (6, 9)              – "var"

    /Classes/MyClass2/Methods/test – (6, 17)            – "MyClass"

  4. Logger says:

    Thanks you.

    Let us see this example:

    var myClass = new MyClass();


    What type will be inferred when Axapta make cross-refrerence for "myClass.CallSomeMethod();"?

    Object or "MyClass" ?

  5. Thanks for the comment Logger.  

    Cross reference is captured, regardless of if the type is inferred, or if you explicitly spellout the type.  

    In the example you quote, then the type is inferred as Common, and not CustTable – which has some negative effects.  That is exactly why I'm recommend you do not use var in that situation.

  6. KimKopowski says:

    uh! the above comment is valid. Is cross-referencing possible when using var?

  7. Logger says:

    Using var, the code becomes:

    var custTable = Xml2Record(xml);  

    custTable.someInvalidMethod(); // No compile error, as Xml2Record() returns a common

    And what about cross-reference ?

    I need CustTable !

    Not common !

    You've broken our main instrument !   :(:(:(:(:(

  8. DAP says:

    It's basically type inferrence, so the type of variable is inferred by the compiler frm the right hand side expression. That means type safety is enforced which is not the case for Object/Common.

  9. Eugen Glasow says:

    How is that different from the "Object"?

Skip to main content