Implementing a Cache Mechanism in D365 F&O Using X++ for Efficient Data Handling

In Dynamics 365 Finance and Operations (D365 F&O), managing cache efficiently is crucial for performance optimization. The global cache mechanism allows for session-specific data to be stored temporarily and retrieved quickly, improving user experience and reducing the number of repeated database queries. This blog explains how to create and use a cache system in D365 F&O using X++.

We will walk through a simple example of how to manage cache using a custom class. We will explore set, get, remove, and check if set operations and how to manage cache for both regular data and container values.

---

Overview of the Cache Management Class

To facilitate cache operations, we will implement a custom class, which provides methods to:

1. Store data in cache.

2. Retrieve data from cache.

3. Check if a specific key exists.

4. Remove data from cache.

The custom class leverages the global cache functionality provided by D365 F&O and stores values with a unique session ID to ensure session-specific data storage.

---

Code Breakdown

Here’s the CacheManager class that implements cache management using the global cache:

x++
public class CacheManager
{
    // This string is appended for container values to avoid type mismatches
    public static const str containerSuffix = "_container";

    // Method to generate a unique session ID based on the user and session
    private static str generateSessionId()
    {
        return curUserId() + "_" + int2Str(sessionId());
    }

    // Get a cached value by its key
    public static anytype getValue(anytype _key, anytype _defaultValue = '')
    {
        return appl.globalCache().get(CacheManager::generateSessionId(), _key, _defaultValue);
    }

    // Get a container value by its key
    public static anytype getContainerValue(anytype _key, anytype _defaultValue = '')
    {
        if (CacheManager::isContainerSet(_key))
        {
            return appl.globalCache().get(CacheManager::generateSessionId() + CacheManager::containerSuffix, _key, _defaultValue);
        }
        return null;
    }

    // Check if a key exists in the cache
    public static boolean isValueSet(anytype _key)
    {
        return appl.globalCache().isSet(CacheManager::generateSessionId(), _key);
    }

    // Check if a container key exists in the cache
    public static boolean isContainerSet(anytype _key)
    {
        return appl.globalCache().isSet(CacheManager::generateSessionId() + CacheManager::containerSuffix, _key);
    }

    // Remove a cached value by its key
    public static boolean removeValue(anytype _key)
    {
        return appl.globalCache().remove(CacheManager::generateSessionId(), _key);
    }

    // Remove a container value by its key
    public static boolean removeContainerValue(anytype _key)
    {
        return appl.globalCache().remove(CacheManager::generateSessionId() + CacheManager::containerSuffix, _key);
    }

    // Set a value in the cache
    public static boolean setValue(anytype _key, anytype _value, boolean _isVolatile = true)
    {
        return appl.globalCache().set(CacheManager::generateSessionId(), _key, _value, _isVolatile);
    }

    // Set a container value in the cache
    public static boolean setContainerValue(anytype _key, anytype _value, boolean _isVolatile = true)
    {
        return appl.globalCache().set(CacheManager::generateSessionId() + CacheManager::containerSuffix, _key, _value, _isVolatile);
    }
}

Explanation of the Code:

1. generateSessionId: Generates a unique session ID for each user, ensuring cache is session-specific.

2. getValue: Retrieves a value from the cache for the given key.

3. getContainerValue: Retrieves a value from the cache for container keys (with a _container suffix to prevent type mismatches).

4. isValueSet: Checks if a regular key exists in the cache.

5. isContainerSet: Checks if a container key exists in the cache.

6. removeValue: Removes a regular key from the cache.

7. removeContainerValue: Removes a container key from the cache.

8. setValue: Sets a value in the cache.

9. setContainerValue: Sets a container value in the cache.

---

Cache Usage in Real Scenarios

1. Setting a Value in Cache:

You can use the following code to store a value in the cache. First, check if the key already exists in the cache, and then remove the old value (if necessary) before setting the new value.

x++
if (CacheManager::isValueSet("OrderID"))
{
    CacheManager::removeValue("OrderID");
}

CacheManager::setValue("OrderID", "ORD12345");

• Explanation: If the key "OrderID" is already set in the cache, it is removed. Then, the new value "ORD12345" is stored in the cache under the key "OrderID".

2. Getting a Value from Cache:

To retrieve the stored value from the cache, use the getValue method as follows:

x++
if (CacheManager::isValueSet("OrderID"))
{
    this.OrderId = CacheManager::getValue("OrderID");
    CacheManager::removeValue("OrderID");
}

• Explanation: This checks if the "OrderID" exists in the cache. If so, the value is retrieved and assigned to this.OrderId. After that, the cache entry is removed.

---

Benefits of Using Cache in D365 F&O:

1. Improved Performance: Reduces repeated database queries by storing frequently accessed data.

2. Session-specific Storage: Ensures that each user's session has isolated cache data.

3. Efficient Data Retrieval: Fast access to cached data without the need to fetch it from the database each time.

---

Conclusion

By implementing a cache mechanism like the one demonstrated above, you can significantly improve the performance and responsiveness of your D365 F&O applications. It helps manage session-specific data effectively, reduces unnecessary database hits, and ensures a seamless user experience.