File Dependency

File dependency provides a mechanism to invalidate the cache data in case of non-relational data sources. Here you can associate a file/folder dependency with a cache item. Whenever that file/folder is removed or modified, NCache will remove its dependent item from cache. Cache clean up thread monitors the dependent file/folder for any change at every CleanInterval.

On cache clean up thread, NCache triggers dependency in the following scenarios:

  • Dependency file is removed/modified.
  • Dependency folder is removed/modified.
  • Dependency is created in the non-existed file/folder, but on the cleanup interval it is created.

Similarly, multiple items can depend on a single file. Any change in file, either by updating the file or deletion, causes the cache to remove the dependent items from the cache. Likewise, an item can create dependency on multiple files in file dependency.

You can also provide a delay called startAfter in file dependency which indicates when to start monitoring the dependent file for any change. In this way NCache will start checking the dependent file after the startAfter time has elapsed.

Pre-Requisites for Using File Dependency

  • Include the following namespace in your application:
    • Alachisoft.NCache.Web.Caching
    • Alachisoft.NCache.Runtime
    • Alachisoft.NCache.Runtime.Dependencies
  • The application must be connected to cache before performing the operation.
  • Cache must be running.
  • Make sure that the data being added is serializable.
  • To ensure the operation is fail safe, it is recommended to handle any potential exceptions within your application, as explained in Handling Failures.
Important

Make sure that the NCache service has access to the file path where the file to be dependent on is placed.

Add Data to Cache with File Dependency

In the following example, the data added in the cache is the content of the file placed at the specified path with dependency on the file. Any change in the file will result in the expiration of the dependent data present in the cache. The expired items will then be removed at the cache CleanInterval.

Important

Note that this API also specifies cache item priority for eviction as well as expiration, so the value for that parameter has been passed as Default, as it is not discussed here.

The Add method adds a new item in the cache whereas the Insert method adds a new item with dependency and if the item already exists in the cache it overwrites its properties.

Tip

You can monitor/verify successful addition through:

try
{
    // Pre-Condition: Cache is already connected

    // Generate a unique key for the fileData
    string key = "FileData";

    // Get the content of the file as string
    string FileData = cache.Get(key) as string;

    // Check if the fileData is already in the cache
    if (string.IsNullOrEmpty(FileData))
    {
        // Read the contents of the file placed at the path
    }

    // Specify the file path to add dependency on the file
    string filepath = "D:\\Dependency.txt";

    // Create the dependency on the file on the specified path
    FileDependency dependency = new FileDependency(filepath);

    // Add the file data in the cache with dependency on the file
    cache.Insert(key, FileData, dependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Normal);
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    // Exception can occur due to:
    // Connection Failures
    // Operation performed during state transfer
    // Operation Timeout
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

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

Add CacheItem to Cache with File Dependency

CacheItem is a custom class provided by NCache which can be used to add data to the cache and also lets you set additional metadata associated with an object of this class. This metadata defines the properties of the item like dependencies, expirations and more. You can refer to all properties of CacheItem here.

The Add method adds a new item in the cache whereas the Insert method adds a new item with dependency and if the item already exists in the cache it overwrites its properties.

Important

Note that this API also specifies cache item priority for eviction as well as expiration, so the value for that parameter has been passed as Default, as it is not discussed here.

In the following example, the data added in the cache is the content of the file placed at the specified path as a CacheItem with dependency on the file. Any change in the file will result in the expiration of the dependent data present in the cache. The expired items will then be removed at the cache CleanInterval.

try
{
    // Pre-Condition: Cache is already connected

    // Generate a unique key for the fileData
    string key = "FileData";

    // Get the content of the file as string
    string FileData = cache.Get(key) as string;

    CacheItem cacheitem = new CacheItem(FileData);

    // Check if the fileData is already in the cache
    if (string.IsNullOrEmpty(FileData))
    {
        // Read the contents of the file placed at the path
    }

    // Specify the file path to add dependency on the file
    string filepath = "D:\\Dependency.txt";

    // Create the dependency on the file on the specified path
    cacheitem.Dependency = new FileDependency(filepath);

    // Add the file data in the cache with dependency on the file
    cache.Insert(key, cacheitem);

    // For successful addition of cacheitem with dependency
    // Update the file and check if cacheitem is present in cache
    // This can be done by using
    // Cache.Contains()
    // Count
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    // Exception can occur due to:
    // Connection Failures
    // Operation performed during state transfer
    // Operation Timeout
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

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

Trigger File Dependency with Delay

If you want to add dependency to an item which is triggered after a particular time, NCache allows you to specify the time interval for that.

The Add method adds a new item in the cache whereas the Insert method adds a new item with dependency and if the item already exists in the cache it overwrites its properties.

Important

Note that this API also specifies cache item priority for eviction as well as expiration, so the value for that parameter has been passed as Default, as it is not discussed here.

In the following example, the data added in the cache is the content of the file placed at the specified path with dependency on the file. The dependency will v\be triggered after a span of 20 minutes. Any change in the file will result in the expiration of the dependent data present in the cache. The expired items will then be removed at the cache CleanInterval.

try
{
    // Pre-Condition: Cache is already connected

    // Generate a unique key for the fileData
    string key = "FileData";

    // Get the content of the file as string
    string FileData = cache.Get(key) as string;

    // Check if the fileData is already in the cache
    if (string.IsNullOrEmpty(FileData))
    {
        // Read the contents of the file placed at the path
    }

    // Specify the file path to add dependency on the file
    string filepath = "D:\\Dependency.txt";

    // Create the dependency on the file on the specified path
    // The dependency starts after 20 minutes 
    FileDependency dependency = new FileDependency(filepath, DateTime.Now.AddMinutes(20));

    // Add the file data in the cache with dependency on the file
    cache.Insert(key, FileData, dependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Normal);
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    // Exception can occur due to:
    // Connection Failures
    // Operation performed during state transfer
    // Operation Timeout
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

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

Add File Dependency on Multiple Files

You can also add file dependency to an item which is dependent on multiple files or folders. This way a single item can be dependent on multiple items using the Add or Insert method.

The Add method adds a new item in the cache whereas the Insert method adds a new item with dependency and if the item already exists in the cache it overwrites its properties.

Important

Note that this API also specifies cache item priority for eviction as well as expiration, so the value for that parameter has been passed as Default, as it is not discussed here.

Following example adds an item with key "1001" which is dependent on two files placed on the specified paths.

try
{
    // Pre-condition: Cache is already connected

    // Get product from database against given ProductID
    Product product = FetchProductByProductID("1001");

    // Generate a unique cache key for this product
    string key = $"Product:{product.ProductID}";

    // Specify the filepaths of the master files
    // Make sure that the network file paths are accessible by NCache Service 
    string[] fileNames = new string[1];
    fileNames[0] = "\\fileserver1\\ProductList.csv";
    fileNames[1] = "\\fileserver1\\OrderList.csv";

    //Adding cache item "Product:1001" with FileDependency on a list of files
    cache.Insert(key, product, new FileDependency(fileNames), Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Normal);

    // For successful addition of item with dependency
    // Update or remove the file 
    // Verify if key is present using:
    // cache.Contains()
    // cache.Count
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    // Exception can occur due to:
    // Connection Failures
    // Operation performed during state transfer
    // Operation Timeout
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

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

Add File Dependency to Existing Cache Items

NCache also provides you with the ease of adding key dependency to an item already present in cache, without re-inserting it into the cache.

Important

This approach is comparatively less lightweight and more cost efficient since items are already present in the cache.

Using SetAttribute() API

This is done through CacheItemAttribute class, which has the property of Dependency to be set against CacheItem. The attribute is then set against the existing key of the item, using the SetAttributes method of Cache class.

The following example adds an item to cache without dependency, and then sets the file dependency for the item using SetAttribute method. This requires no need to add the item again to the cache.

try
{
    // Pre-condition: Cache is already connected

    // Generate a unique key for the fileData
    string key = "FileData";

    // Get the content of the file as string
    // Make sure that the item already exists in the cache
    string FileData = cache.Get(key) as string;

    // Specify the filepath 
    string filepath = "\\FileHost\\ProductList.csp";

    // Create a file dependency where key is depenent on the file on specified path
    FileDependency dependency = new FileDependency(filepath);

    // Create a CacheItemAttribute for dependency
    CacheItemAttributes attr = new CacheItemAttributes();
    attr.Dependency = dependency;

    // Set the attribute of dependency against key
    cache.SetAttributes(key, attr);

    // Monitor/Verify dependency through either:
    // PerfMon Counters
    // cache.Contains(key)
    // cache.Count
}
catch (OperationFailedException ex)
{
    // NCache specific exception

    // Exception can occur due to:
    // Connection Failures
    // Operation performed during state transfer
    // Operation Timeout
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

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

Using AddDependency() Method

File Dependency can be added to existing items using the AddDependency method.

The following example adds an item to cache without dependency, and then sets the file dependency for the item using AddDependency method. This requires no need to add the item again to the cache.

try
{
    // Pre-condition: Cache is already connected

    // Generate a unique key for the fileData
    string key = "FileData";

    // Get the content of the file as string
    // Make sure that the item already exists in the cache
    string FileData = cache.Get(key) as string;

    // Specify the filepath of the master file
    string filepath = "\\FileHost\\ProductList.csp";

    // Create a file dependency where key is depenent on the file on specified path
    FileDependency dependency = new FileDependency(filepath);

    // Add dependency to the item using the AddDependency method
    bool itemAdded = cache.AddDependency(key, dependency, false);

    if (itemAdded == true)
    {
        // Depedency is added
    }
    else
    {
        // Dependency failed to add
    }
}
catch (OperationFailedException ex)
{
    // NCache specific exception

    // Exception can occur due to:
    // Connection Failures
    // Operation performed during state transfer
    // Operation Timeout
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

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

See Also

Custom Dependency
Sync Cache with Database
Data Relationship in Cache