Configure Invalidation Attributes for Data Structures in Cache

NCache provides invalidation mechanisms for distributed data structures that control their lifetime and removal behavior in the cache. These mechanisms are configured through the DataTypeAttributes class at the time of data structure creation and apply to all supported distributed data structures. Since these settings define the core behavior of the data structure, they must be specified during initialization and cannot be changed afterward.

The data structures can be invalidated from the cache using:

These attributes are specified during the data structure creation using the DataTypeAttributes class and cannot be modified once a data structure is created in the cache. Moreover, these invalidation attributes can be specified against all data structures.

Note

Key dependencies can also be configured between the CacheItem and data structures.

Prerequisites

Before using the NCache client-side APIs, ensure that the following prerequisites are fulfilled:

Use Invalidation Attributes with Data Structures

The following code sample creates a set OrderIDSet that is dependent on a Product object in the cache. The OrderIDSet is assigned an expiration value of 15 minutes and its priority is set to high. If the Product is modified in the cache, OrderIDSet is removed from the cache.

try
{
  // Precondition: Cache is already connected

  // Product exists in cache with key "Product:1001"
  string productKey = "Product:1001";

  // Specify attributes for HashSet
  var attributes = new DataTypeAttributes();

  // Specify priority for eviction
  attributes.Priority = CacheItemPriority.High;

  // Specify Absolute expiration of 15 minutes
  var expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(15));
  attributes.Expiration = expiration;

  // Specify key dependency of orderKey on customerKey
  var keyDependency = new KeyDependency(productKey);
  attributes.Dependency = keyDependency;

  // Create HashSet which is dependent on product:1001
  // Specify unique cache key for set
  string orderKey = "OrderIDSet";
  IDistributedHashSet<int> orderIDSet = cache.DataTypeManager.CreateHashSet<int>(orderKey, attributes);

  // Check if the orderIDSet exists in cache:
  // After 15 minutes or
  // If product is modified in cache
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    if(ex.ErrorCode == NCacheErrorCodes.KEY_ALREADY_EXISTS)
    {
        // An item with the same key already exists
    }
    else if (ex.ErrorCode == NCacheErrorCodes.CACHEITEM_IN_DATA_STRUCTURES)
    {
        // Data structures cannot be of CacheItem type
        // CacheItems cannot be added in data structures
    }
    else
    {
        // NCache specific exception
        // Exception can occur due to:
        // Connection Failures
        // Operation Timeout
        // Operation performed during state transfer
    }
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}
Note

To ensure the operation is fail-safe, it is recommended to handle any potential exceptions within your application, as explained in Handling Failures.

Additional Resources

NCache provides a sample application for configuring invalidation attributes with data structures on GitHub.

See Also

.NET: Alachisoft.NCache.Client.DataTypes namespace.
Java: com.alachisoft.ncache.client.datastructures namespace.
Node.js: DataStructureManager class.