How to Convert Between List and Container in X++ for JSON Serialization

How to Convert Between List and Container in X++ for JSON Serialization

In Dynamics 365 Finance and Operations (D365FO), working with data serialization, especially when dealing with lists or arrays, can be a bit tricky. The native List class and container type don't work in exactly the same way when it comes to serialization in JSON. In this blog post, we'll explore how to convert between a List of strings and a container, a fundamental task for serializing collections of data correctly in D365FO.

What Are Lists and Containers?

• List: A dynamic collection of elements. In X++, the List class is used to store collections of objects, such as strings, integers, or other data types.

• Container: A generic type in X++ that can store multiple data types. It's often used to hold values of different types (like integers, strings, or even other containers). For serialization, container is the preferred type when dealing with collections in Dynamics 365.

When you need to serialize a collection of strings (such as tags, categories, etc.) as part of a DataContract class for an API or service, you might encounter issues since X++ doesn't natively allow you to directly serialize a List of strings into JSON. Instead, you'll need to convert the List to a container, serialize it, and later convert it back to a List.

Why Do We Need This Conversion?

When using AIF (Application Integration Framework) or Data Contracts in D365FO, the container type is automatically supported for JSON serialization. However, List is not directly serializable. As a result, we need to implement conversion methods to handle this transformation when dealing with collections like strings or integers.

Here, we'll walk through how to create two utility methods that help convert between a List and a container in X++.

The Conversion Methods

1. List to Container Conversion

This method converts a List of strings into a container. The key here is iterating over each item in the List and adding it to a new container:

x++
public static container listToContainer(List listOfStrings)
{
    container result;
    ListEnumerator enumerator = listOfStrings.getEnumerator();

    while (enumerator.moveNext())
    {
        result += enumerator.current();
    }

    return result;
}

Explanation:

• We initialize an empty container called result.

• The ListEnumerator allows us to loop through the List one item at a time.

• We use the += operator to add each item from the List into the container.

• Finally, the container is returned, now holding the same items as the original List.

2. Container to List Conversion

The reverse operation converts a container back into a List of strings. Here's the implementation:

x++
public static List containerToList(container con)
{
    List result = new List(Types::String);
    int i;

    for (i = 1; i <= conLen(con); i++)
    {
        result.addEnd(conPeek(con, i));
    }

    return result;
}

Explanation:

• We initialize an empty List of type string called result.

• The conLen function gets the number of elements in the container.

• We loop through the container, extracting each element using conPeek() and adding it to the List using addEnd().

• Finally, we return the populated List.

---

Using the Conversion Methods in Your Code

Let's see how you can use these helper methods in a typical use case, such as managing shipment tags in a Data Contract class.

Updated ShipmentTags Method Example

Here’s how you would use the conversion methods in a ShipmentTags property in your Data Contract:

x++
[DataMemberAttribute(#ShipmentTags), AifCollectionTypeAttribute(#_ShipmentTags, Types::String)]
public List ShipmentTags(List _ShipmentTags = containerToList(fpShipmentTags.parmValue()))
{
    if (!prmisDefault(_ShipmentTags))
    {
        fpShipmentTags.parmValue(listToContainer(_ShipmentTags));
    }

    return _ShipmentTags;
}

Explanation:

• Serialization: When the method is called, if a List of strings is passed, it gets converted to a container for serialization. This is achieved through the listToContainer() method.

• Deserialization: When deserializing data, the container is converted back to a List of strings using the containerToList() method.

Now, you can easily assign values to the ShipmentTags property as follows:

x++
// Create a list of strings
List shipmentTagsList = new List(Types::String);
shipmentTagsList.addEnd("Fragile");
shipmentTagsList.addEnd("Express");
shipmentTagsList.addEnd("HandleWithCare");

// Create an instance of your contract class
CarIntApiTrkCreateContract contract = CarIntApiTrkCreateContract::construct();

// Assign the list to the ShipmentTags property
contract.ShipmentTags(shipmentTagsList);

This will serialize into the following JSON:

json
"shipmentTags": ["Fragile", "Express", "HandleWithCare"]

Conclusion

By implementing the ListToContainer and ContainerToList conversion methods, you can easily manage collections of primitive types (like strings) for JSON serialization in Dynamics 365 Finance and Operations. These utility methods allow you to seamlessly work with List objects in your code while ensuring compatibility with D365FO's serialization framework.

If you're building a custom service or API that involves sending or receiving lists of data, these conversion methods will be crucial for ensuring that data is properly serialized and deserialized. They streamline your development process, avoiding the need for manual conversion every time you work with lists in Data Contracts.