Collection Classes in Ax 2012 : Set , Map , List , Array

Collection Classes in Ax 2012

Collection Classes

We cannot store objects in arrays (x++ class) or containers. The Microsoft Dynamics AX collection classes have been designed for storing objects. 

Below are collection classes: Set , Map , List , Array 

A Set is used for the storage and retrieval of data from a collection in which the members are unique. The values of the members serve as the key according to which the data is automatically ordered. Thus, it differs from a List collection class where the members are placed into a specific position, and not ordered automatically by their value.

The functionality of Sets is similar with list.  A Set is just an unordered list of items, while a list of items held by a Map
are indexed via via a key.

static void Set(Args _args)

{

    Set setOne;

    Set setTwo;

    SetEnumerator enumerator;

    Int value;

    setOne = new Set(types::Integer);

    setOne.add(4);

    setOne.add(6);

    setOne.add(3);

   

    enumerator = setOne.getEnumerator();

    while (enumerator.moveNext())

    {

        value = enumerator.current();

        info(strFmt("%1",value));      

    }

}

Output :- 3

                 4

                 6

A List object contains members that are accessed sequentially. Lists are structures that can contain members of any X++ type. All the members in the same list must be of the same type.

List:
Lists are structures that may contain any number of elements that are
accessed sequentially. Lists may contain values of any X++ type. All the
values in the list must be of __the same__(this is the main difference
between lists and containers) type, given in the creation of the list. The
implementation of lists is such that traversal of the list elements is __very
fast.

static void List(Args _args)

{

    List integerList = new List(Types::Integer);

    ListEnumerator enumerator;

    // Add some elements to the list

    integerList.addEnd(1);

    integerList.addEnd(4);

    integerList.addEnd(3);

    // Set the enumerator

    enumerator = integerList.getEnumerator();

    // Go to beginning of enumerator

    enumerator.reset();

    //Go to the first element in the List

    while(enumerator.moveNext())

    {

        info(strfmt("%1", enumerator.current()));

    }

}

Output :- 1

                 4

                 3

A Map object associates one value (the key) with another value. Both the key and value can be of any valid X++ type, including objects. The types of the key and value are specified in the declaration of the map. The way in which maps are implemented means that access to the values is very fast.

A map is a data type that associates one (key) value with another value [An

analog - a small table in memory with two fields: Keys, Values]. Both the key

and value values may be of any valid X++ type, including objects. The types

of the key and the value are given in the declaration of the map. The

implementation of maps is such that access to the values is _very fast_.

Don’t confuse map X++ types with Map objects in AOT, wich are used for

mapping tables with similar structures of fields

static void Map(Args _args)

{

    Map mapTest;

    MapEnumerator enumerator;

  

    mapTest = new Map(Types::String, Types::Integer);

   

    mapTest.insert("One", 1);

    mapTest.insert("Two", 2);

   

    enumerator = mapTest.getEnumerator();

    while (enumerator.moveNext())

    {

        info(strfmt("Key - %1 , Value  - %2.",enumerator.currentKey(),enumerator.currentValue()));

    }

}

Output:- Key - One , Value  - 1.

                Key - Two , Value  - 2.

Containers:

Containers are dynamic and have no limits. They can contain elements of

almost all data types: Boolean, integer, real, date, string, container,

arrays, tables, and extended data types. However, objects may not be stored

in containers.

Containers in AX are used very often. It’s easy to work with them. But…

data in containers are stored sequentially, and thus retrieved sequentially.

This means that containers provide slower data access if you are working with

_large numbers_ of records. In case of large numbers of records use temporary

tables.