X++, C# Comparison: Array Syntax [AX 2012]

Updated: November 15, 2010

Applies To: Microsoft Dynamics AX 2012 R3, Microsoft Dynamics AX 2012 R2, Microsoft Dynamics AX 2012 Feature Pack, Microsoft Dynamics AX 2012

This topic compares array syntax between X++ and C#.

There are similarities and differences in the features and syntax for arrays in X++ versus C#.


Overall there is much similarity in the syntax and treatment of arrays in X++ and C#. However there are many differences.


The following table lists areas in the [] syntax for arrays that are different for X++ and C#.






An array is declared with square brackets appended to the variable name.

An array is declared with square brackets appended to the data type.

int myInts[]; // X++

An X++ array cannot be a parameter in a method.


int[] myInts; // C#


The array syntax supports only primitive data types, such as int and str. The syntax does not support classes or tables.

The array syntax supports primitive data types and classes.

In X++ you can use the Array Array for an array of objects.


X++ is limited to single dimension arrays (myStrings[8]).

C# adds support for multi-dimensional arrays (myStrings[8,3]) and for jagged arrays (myStrings[8][3]).

In X++ you cannot have an array of arrays. However, there is advanced syntax for limiting the amount of active memory that a large array can consume, which looks like the multi-dimensional syntax in C#: int intArray[1024,16];. For more information, see Best Practice Performance Optimizations: Swapping Arrays to Disk.


In X++ an array is a special construct but it is not an object.

In C# all arrays are objects regardless of syntax variations.

X++ does have an Array class, but its underlying mechanism differs from arrays created by using the [] syntax.

In C# all arrays use the same underlying mechanism, regardless of whether [] syntax of the System.Array class is used in your code.


In X++ the length of a static sized array is determined in the declaration syntax.

In C# the size of an array is determined when the array object is constructed.

When you use the [] declaration syntax in X++, no more preparation is needed before you assign values to the array.

In C# you must declare and then construct the array before assigning to it.


An X++ array can have a dynamic length that can be increased even after population has begun. This applies only when the array is declared without a number inside the []. Performance might be slowed if the length of the dynamic array is increased many times.

In C# the length of an array cannot be changed after the length is set.

In the following fragment of X++ code, only the myInts array is dynamic and can increase in size.

int myInts[];

int myBools[5];


myInts[2] = 12;

myInts[3] = 13;

myBools[6] = 26; //Error


You can get the length of some arrays by using the dimOf function.

C# arrays are objects that have a Length property.

No comments.


Array indexing is 1 based.

Array indexing is 0 based.

mtIntArray[0] would cause an error in X++.


In X++ a constant value is best achieved by using the #define precompiler directive.

In C# you can decorate your variable declaration with the keyword const, to achieve a constant value.

X++ has no const keyword. C# cannot assign values to variables that are created by its #define precompiler directive.

The following code samples show how arrays of primitive data types are handled. The first sample is in X++, and the second sample is in C#. Both samples achieve the same results.

Cc967423.collapse_all(en-us,AX.60).gifX++ Sample

static void JobRs005a_ArraySimple(Args _args)

    // Static length.
    str sSports[#macroArrayLength];

    // Dynamic length, changeable during run time.
    int years[];
    int xx;
    Global::warning("-------- SPORTS --------");
    sSports[#macroArrayLength] = "Baseball";

    for (xx=1; xx <= #macroArrayLength; xx++)
        info(int2str(xx) + " , [" + sSports[xx] + "]");
    warning("-------- YEARS --------");
    years[ 4] = 2008;
    years[10] = 1930;

    for (xx=1; xx <= 10; xx++)
        info(int2str(xx) + " , " + int2str(years[xx]));


The output to the Infolog is as follows:

Message (14:16:08)
-------- SPORTS --------
1 , []
2 , []
3 , [Baseball]
-------- YEARS --------
1 , 0
2 , 0
3 , 0
4 , 2008
5 , 0
6 , 0
7 , 0
8 , 0
9 , 0
10 , 1930

Cc967423.collapse_all(en-us,AX.60).gifC# Sample

using System;
public class Pgm_CSharp
    static public void Main( string[] args )
        new Pgm_CSharp().Rs005a_CSharp_ArraySimple();
    private void Rs005a_CSharp_ArraySimple()
        const int const_iMacroArrayLength = 3;

        // In C# the length is set at construction during run.
        string[] sSports;
        int[] years;

        int xx;
        Console.WriteLine("-------- SPORTS --------");
        sSports = new string[const_iMacroArrayLength];
        sSports[const_iMacroArrayLength - 1] = "Baseball";

        for (xx=0; xx < const_iMacroArrayLength; xx++)
            Console.WriteLine( xx.ToString()
                + " , [" + sSports[xx] + "]" );
        Console.WriteLine("-------- YEARS --------");
        // In C# you must construct the array before assigning to it.
        years = new int[10];
        years[ 4] = 2008;
        years[10 - 1] = 1930;

        for (xx=0; xx < 10; xx++)
            Console.WriteLine( xx.ToString()
                + " , [" + years[xx].ToString() + "]" );
} // EOClass


The output from the C# program to the command line console is as follows:

-------- SPORTS --------
0 , []
1 , []
2 , [Baseball]
-------- YEARS --------
0 , [0]
1 , [0]
2 , [0]
3 , [0]
4 , [2008]
5 , [0]
6 , [0]
7 , [0]
8 , [0]
9 , [1930]

The container is a special data type that is available in X++. It can be considered as similar to an array, or similar to a List collection. For more information, see Containers.

Announcements: New book: "Inside Microsoft Dynamics AX 2012 R3" now available. Get your copy at the MS Press Store.

Community Additions