Extensible Dependency Usage and Implementation

Note

This feature is only available in NCache Enterprise Edition.

In extensible dependency, the users can have their own dependencies scenarios that invalidate an item when a certain criterion is met. In this way, items can be expired from cache in a number of flexible ways where expiration logic meets the user’s business requirements. To implement extensible dependency in your application, NCache provides an abstract class ExtensibleDependency. Follow the guide below to understand how to implement and use this class.

Tip

Refer to Custom Cache Dependencies to get acquainted with all cache dependency custom methods provided by NCache.

Step 1: Implement ExtensibleDependency Class

The first step in introducing your own logic for Extensible Dependency is to implement the ExtensibleDependency class.

Prerequisites

  • Install either of the following NuGet packages in your application based on your NCahce edition:
  • To override the ExtensibleDependency class, include the Alachisoft.NCache.Runtime.Dependencies namespace in your application:
  • The class implementing ExtensibleDependency must be marked as Serializable, along with any parameters the process code might be taking in.
  • The project must be implemented as a Class Library (.dll) in Visual Studio. This will be deployed on NCache cluster.

Let's suppose there is a grocery store which has a big collection of products which customers often buy. These products can be cached from the database to check their units in stock. The following dependency implementation polls the Northwind database and expires all the Products for which units in stock are less than 100.

[Serializable]
public class Dependency : ExtensibleDependency
{
    // Class parameters
    [NonSerialized]
    OleDbConnection connection;

    public Dependency(int productId, string connString)
    {
        connection =  new OleDbConnection(connString);
        connection.Open();
        productID = productId;
    }

    public bool HasChanged()
    {
        if (GetAvailableUnits(productID) < 100)
            return true;
        return false;
    }

    internal int GetAvailableUnits(int productID)
    {
        if (connection == null)
        {
            connection = new OleDbConnection(connString);
            connection.Open();
        }

        OleDbCommand command = connection.CreateCommand();
        command.CommandText = String.Format(CultureInfo.InvariantCulture,
            "Select UnitsInStock From Products" +
            " where ProductID = {0}", productID);

        int availableUnits = -1;
        OleDbDataReader reader = null;
        reader = command.ExecuteReader();
        if (reader.Read())
        {
            availableUnits = Convert.ToInt32(reader["UnitsInStock"].ToString());
        }
        reader.Close();
        return availableUnits;
    }
    protected void DependencyDispose()
    {
        // Dispose off all resources
    }
    // This class is to be deployed in NCache
}

Step 2: Implement Custom Dependency Provider

A custom dependency provider for extensible dependency implements your logic that you created in step 1 on server side. Here's how you can implement your own extensible dependency provider:

Prerequisites

  • Install either of the following NuGet packages in your application based on your NCahce edition:
  • To utilize the APIs, include the following namespaces in your application:
    • Alachisoft.NCache.Runtime.Dependencies
    • Alachisoft.NCache.Runtime.CustomDependencyProviders
    • Alachisoft.NCache.Runtime
    • Alachisoft.NCache.Runtime.Exceptions
  • This should be a class library project.

This class implements the CustomDependencyProvider interface that is required to successfully create and deploy an Extensible Dependency Provider.

public class ExtensibleDependencyProvider : ICustomDependencyProvider
{
    public void Init(IDictionary<string, string> parameters, string cacheName)
    {
        // Initialize cache and class parameters
    }

    public Dependency CreateDependency(string key, IDictionary<string, string> dependencyParameters)
    {
        int productId = 0;
        string connectionString = "";

        if (dependencyParameters != null)
        {
            if (dependencyParameters.ContainsKey("ProductID"))
                productId = Int32.Parse(dependencyParameters["ProductID"]);

            if (dependencyParameters.ContainsKey("ConnectionString"))
                connectionString = dependencyParameters["ConnectionString"];

            // Create extensible dependency 
            Dependency dependency = new Dependency(productId, connectionString);
            return dependency;
        }
        else
        {
            // No parameters found
        }
    }

    public void Dispose ()
    {
        // Dispose off all resources
    }
}

Step 3: Deploy Implementation on Cache

Deploy this class and all dependent assemblies on NCache by referring to Deploy Providers in Administrator’s Guide for help.

Step 4: Use Extensible Dependency

Once extensible dependency class has been implemented and deployed, it is ready to be used in your application.

Prerequisites

  • Install either of the following NuGet packages in your application based on your NCahce edition:
  • To utilize NCache API, include the following namespaces in your application:
    • Alachisoft.NCache.Client
    • Alachisoft.NCache.Runtime.Dependencies
    • Alachisoft.NCache.Runtime.Exceptions
  • The Dependency class must be deployed on cache.
  • Cache must be running.
  • The application must be connected to cache before performing the operation.
  • To ensure the operation is fail safe, it is recommended to handle any potential exceptions within your application, as explained in Handling Failures.

The following code shows how to add data into the cache using the Insert method with extensible dependency enabled.

try
{   // Specify the connection string
    string connectionString = ConfigurationManager.AppSettings["connectionstring"];

    // Fetch the product to be added to the cache
    Product product = FetchProductFromDB(productId);

    // Specify the unique key of the item
    string key = $"Product:{product.ProductID}";

    // Create a cacheItem
    var cacheItem = new CacheItem(product);

    // Create dictionary for dependency parameters 
    IDictionary<string, string> param = new Dictionary<string, string>();
    param.Add("ProductID", product.Id.ToString());
    param.Add("ConnectionString", connectionString);

    // Create Extensible Dependency using Provider and Add it to Cache Item
    CustomDependency customDependency = new CustomDependency(ConfigurationManager.AppSettings["ProviderName"], param);
    cacheItem.Dependency = customDependency;

    // Add cacheItem to the cache with dependency
    cache.Insert(key, cacheItem);
}
catch (OperationFailedException ex)
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

Additional Resources

NCache provides sample application for extensible dependency on GitHub.

See Also

How to Configure Custom Dependency
Cache Data Dependency on External Source
WAN Replication across Multi Datacenters through Bridge
Data Source Providers (Backing Source)