Mapping DAC Type to PXCache Item Type in PXGraph

Explicit Cache Mapping Initialization

Let's start with the explicit specification of cache mappings for a graph. This is done by overriding the virtual InitCacheMapping method of the graph. Here is an example from the VendorShipmentEntry graph.

// InitCacheMapping in VendorShipmentEntry
public override void InitCacheMapping(Dictionary<Type, Type> map)
{
    base.InitCacheMapping(map);

    this.Caches.AddCacheMapping(typeof(INLotSerialStatus), typeof(INLotSerialStatus));
}

You can see the following in this code:

• You need to call the base InitCacheMapping method before specifying a custom cache mapping.
• You can add cache mappings with the AddCacheMapping method. The first parameter is the DAC type and the second is the cache item type.
• There is only one cache mapping added in the example. Most of the DACs, which are used in Acumatica's application logic, do not have inheritors and complex DAC hierarchy. Therefore, cache mappings implicitly created for them by the framework is trivial. The DAC type and the cache item type are the same.
• By specifying cache mapping from INLotSerialStatus to INLotSerialStatus we ensure that cache mapping for the DAC is stable and is not affected by new graph views.

You can also use the map parameter to edit the collection of cache mappings. The following code from ARInvoiceEntry demonstrates this approach:

// InitCacheMapping in ARInvoiceEntry
public override void InitCacheMapping(Dictionary<Type, Type> map)
{
    base.InitCacheMapping(map);
    map.Add(typeof(CT.Contract), typeof(CT.Contract));
}

Both examples basically do the same. The map parameter references the internal cache mapping dictionary, which is also modified by the AddCacheMapping method. You can see during the debug that the map parameter gets new items after a call to AddCacheMapping. However, there are particular differences between these approaches, which are the following:

• Using the map parameter is more flexible. In addition to adding new code mappings you can delete or modify existing ones. However, it also requires more caution. For example, if you try to call map.Add to add mappings for the same DAC type in multiple places (such as in InitCacheMapping overrides in base and derived graphs), you will get the following exception: An item with the same key has already been added.
• The AddCacheMapping method is more limiting but also is more safe. It doesn't allow you to modify existing cache mappings and always checks if a mapping for a given DAC type is already present before adding a new cache mapping.

Finally, there is AddCacheMappingsWithInheritance helper method that allows you to map a DAC type and all its base DAC types to itself. This is useful when you have a derived DAC and you want to map both it and all its base types to a single graph cache. Here is an example from the VendorMaint graph:

// InitCacheMapping in VendorMaint
public override void InitCacheMapping(Dictionary<Type, Type> map)
{
    base.InitCacheMapping(map);

    Caches.AddCacheMappingsWithInheritance(this,typeof(VendorR)); 
    Caches.AddCacheMappingsWithInheritance(this,typeof(CRLocation));  
}