Implement Cache Loader and Refresher

Note

This feature is only available in NCache Enterprise Edition.

To configure Cache Startup Loader, ICacheLoader interface needs to be implemented and then configured using NCache Web Manager or NCache PowerShell cmdlet. NCache uses this custom provider to load and refresh data from the configured data source. On cache startup, NCache calls the implemented LoadDatasetOnStartup method to load data into the cache. It then uses the RefreshDataset method to refresh the data loaded in the cache.

In this example, you implement the ICacheLoader interface to configure our custom loader and refresher logic. Let's suppose you configured two datasets from NCache Web Manager: "Products" and "Suppliers". What the following implementation does is that it loads products and suppliers on cache startup, refreshes this dataset on their specified refresh time, and implements a GetDatasetsToRefresh method that fetches the datasets to refresh along with their refresh interval.

For more detail on the components of Cache Loader, refer to the chapter Components of Cache Startup Loader and Refresher.

Note

Before implementing cache startup loader and refresher, make sure that:

  • Loader service is running
  • Firewall is disabled.

Pre-Requisites

  • To utilize the following APIs, include the following namespace in your application:
    • Alachisoft.NCache.Client
    • Alachisoft.NCache.Runtime.CacheLoader
    • Alachisoft.NCache.Runtime.Caching
    • Alachisoft.NCache.Runtime.Dependencies
  • Data being added into cache must be marked serializable.
  • For API details, refer to: ICache, CacheItem, ICacheLoader.
  • This should be a class library project using Microsoft Visual Studio.
  • Make sure to configure the Cache Loader using NCache Web Manager or PowerShell cmdlet on NCache cluster.

Initialize Cache Startup Loader and Refresher

The following code how to implement the Init method of the ICacheLoader class.

public void Init(IDictionary<string, string> parameters, string cacheName)
{
    cache = CacheManager.GetCache(cacheName);
    connectionString = parameters.ContainsKey("ConnectionString") ? parameters["ConnectionString"] : null;
    if (connectionString != null)
    {
        connection = new SqlConnection(connectionString);
    }
}

Load Data on Cache Startup

The following implementation of ICacheLoader fetches a Product from data source and adds it to the cache to startup. The LoadDatasetOnStartup returns a user context that holds the information about the data loaded in the cache.

public object LoadDatasetOnStartup(string dataset)
{
    // Create a list of datasets to load at cache startup
    IList<object> datasetToLoad;

    switch (dataSet.ToLower())
    {
        // If dataset is "products", fetch products from data source to load in cache
        case "products":
            datasetToLoad = FetchProductsFromDataSource();

            // Insert fetched product in the cache
            foreach (var product in datasetToLoad)
            {
                string key = $"ProductID:{product.Id}";
                cache.Insert(key, product);
            }
            break;

        // If dataset is "suppliers", fetch suppliers from data source to load in cache    
        case "suppliers":
            datasetToLoad = FetchSuppliersFromDataSource();

            // Insert fetched supplier in the cache
            foreach (var supplier in datasetToLoad)
            {
                string key = $"SupplierID:{supplier.Id}";
                cache.Insert(key, supplier);
            }
            break;

        default:
            // Invalid dataset
    }

    // User context is the time at which datasets were loaded in the cache
    object userContext = DateTime.Now; 
    return userContext;
}

Refresh Dataset

The following code implements how to refresh the data that has been loaded in the cache on startup whenever Refresher is invoked. The RefreshDataset method uses the user context returned by the LoadDatasetOnStartup method to verify which data to refresh. 

public object RefreshDataset(string dataset, object userContext)
{
    DateTime? lastRefreshTime;
    switch (dataset.ToLower())
    {
        // If dataset is "products", fetch updated products from data source
        case "products":
            lastRefreshTime = userContext as DateTime?;
            IList<Product> productsToRefresh = FetchUpdatedProducts(lastRefreshTime) as IList<Product>;

            // Insert updated products in the cache
            foreach (var product in productsToRefresh)
            {
                string key = $"ProductID:{product.Id}";
                CacheItem cacheItem = new CacheItem(product);
                _cache.Insert(key, cacheItem);
            }
            break;

        // If dataset is "supplier", fetch updated suppliers from data source
        case "suppliers":
            lastRefreshTime = userContext as DateTime?;
            IList<Supplier> suppliersToRefresh = FetchUpdatedSuppliers(lastRefreshTime) as IList<Supplier>;

            // Insert updated suppliers in the cache
            foreach (var supplier in suppliersToRefresh)
            {
                string key = $"SupplierID:{supplier.Id}";
                CacheItem cacheItem = new CacheItem(supplier);
                _cache.Insert(key, cacheItem);
            }
            break;

        default:
            // Invalid dataset
    }

    // User context is the time at which datasets were refreshed
    userContext = DateTime.Now;
    return userContext;
}

Get Datasets To Refresh

The logic where you assign a refresh interval to your datasets is defined in the GetDatasetsToRefresh method. This method takes user context and assigns RefreshPreference depending upon the specific key in the dataset. 

public IDictionary<string, RefreshPreference> GetDatasetsToRefresh(IDictionary<string, object> userContexts)
{
    DateTime? lastRefreshTime;
    bool datasetHasUpdated;

    // Create a dictionary for datasets to refresh with their refresh preference 
    IDictionary<string, RefreshPreference> DatasetsToRefresh = new Dictionary<string, RefreshPreference>();

    foreach (var dataset in userContexts.Keys)
    {
        switch (dataset.ToLower())
        {
            // If dataset is "products", 
            // check if dataset has been updated in data source
            // if yes, then refresh the dataset now
            case "products":
                lastRefreshTime = userContexts[dataset] as DateTime?;
                datasetHasUpdated = HasProductDatasetUpdated(dataset, lastRefreshTime);
                if (datasetHasUpdated)
                {
                    DatasetsToRefresh.Add(dataset, RefreshPreference.RefreshNow);
                }
                break;

            // If dataset is "suppliers",
            // check if dataset has been updated in data source
            // if yes, then refresh dataset on next time of day
            case "suppliers":
                lastRefreshTime = userContexts[dataset] as DateTime?;
                datasetHasUpdated = HasSupplierDatasetUpdated(dataset, lastRefreshTime);
                if (datasetHasUpdated)
                {
                    DatasetsToRefresh.Add(dataset, RefreshPreference.RefreshOnNextTimeOfDay);
                }
                break;

            default:
                // Invalid dataset
        }               
    }

    // Return the dictionary containing datasets to refresh on polling with their refresh preferences
    return DatasetsToRefresh;
}

Dispose All Resources

In the end, calling the Dispose method ensures that you have closed/deleted all resources. 

public void Dispose()
{
    // Dispose off all resources like
    connection.Close();
}

Important

Configure Cache Loader/Refresher on NCache by referring to Configure Cache Loader and Refresher in Administrator’s Guide for help.

See Also

Components of Cache Startup Loader and Refresher
Implementation of Cache Loader and Refresher
Data Source Providers (Backing Source)
Custom Cache Dependencies