AX / Dynamics 365 For Finance and Operations blog

In Dynamics 365 Finance and Operations (D365FO), there are scenarios where developers need to work with table instances dynamically without hardcoding their names. This is especially useful in generic frameworks or scenarios where the table to be used is determined at runtime. In this article, we’ll explore how to dynamically create table instances using only the table name.

Why Dynamic Table Instances?

Dynamic table instantiation allows developers to:

• Build reusable and flexible code.
• Handle multiple tables with a single function or logic.
• Work with tables whose names or structures are not known at design time.

The Key: DictTable and Common

D365FO provides powerful runtime metadata classes such as DictTable, which allows us to fetch table information dynamically. Combined with the Common class, we can work with table records without knowing their types in advance.

Here’s a step-by-step guide to creating a dynamic table instance:

Code Example

public static void createDynamicTableInstance(str tableName)
{
    DictTable dictTable;
    Common common;
    TableId tableId;

    // Step 1: Convert table name to TableId
    tableId = tableName2Id(tableName);

    if (tableId)
    {
        // Step 2: Create a DictTable object
        dictTable = new DictTable(tableId);

        if (dictTable)
        {
            // Step 3: Create a record instance dynamically
            common = dictTable.makeRecord();

            // Output basic information
            info(strFmt("Instance created for table: %1", tableName));
            info(strFmt("Number of fields: %1", dictTable.fieldCnt()));

            // Step 4: Insert a dynamic record (example logic)
            ttsBegin;
            common.(fieldName2Id(tableId, 'FieldName')) = "Value"; // Replace 'FieldName' with an actual field
            common.insert();
            ttsCommit;

            info("Record inserted dynamically.");
        }
        else
        {
            error("Failed to create a DictTable instance.");
        }
    }
    else
    {
        error(strFmt("Table '%1' does not exist.", tableName));
    }
}

How It Works

1. tableName2Id: Converts the table name to its corresponding TableId. If the table doesn’t exist, this function returns zero.
2. DictTable: Provides metadata about the table, including its structure, field count, and type.
3. makeRecord: Dynamically creates a Common instance representing a record of the specified table.
4. Dynamic Field Access: Using fieldName2Id, you can access fields dynamically without hardcoding field names.

Practical Use Cases

• Generic Import Frameworks: Process data from external sources and insert it into different tables based on runtime configuration.
• Audit or Logging Mechanisms: Dynamically track changes across multiple tables without hardcoding logic for each one.
• Dynamic CRUD Operations: Build tools for handling generic Create, Read, Update, and Delete operations.

Caveats

While this approach is highly flexible, it has some limitations:

• Performance Overhead: Dynamic operations are slower than static code. Use them judiciously in performance-critical scenarios.
• Field-Level Validation: Ensure that field names and data types align with the target table to avoid runtime errors.

Conclusion

Dynamic table instantiation in D365FO is a powerful technique that empowers developers to build flexible and reusable solutions. By leveraging classes like DictTable and Common, you can create robust frameworks that adapt to changing requirements and simplify table-based operations.