Write-through Cache Provider Configuration and Implementation

To use Write-through caching, you need to implement the IWriteThruProvider interface for .NET and the WriteThruProvider interface for Java. NCache will use this custom implementation to write data on the data source. Please refer to Configuring Write-through Cache in Administrators'Guide for more details.

Warning

If the Write-through cache provider is specified in client.ncconf in the default-writethru-provider tag and also through API, then the provider in API will overwrite the one specified in client.ncconf.

Note

Write-Through is [Deprecated] for NCache Java.

Prerequisites

To learn about the standard prerequisites required to work with all NCache server-side features including Write-through cache please refer to the given page on Server Side API Prerequisites.
This should be a class library project using Microsoft Visual Studio.
Make sure to Deploy WriteThrough Provider using the NCache Management Center.
For API details refer to: IWriteThruProvider, WriteToDataSource.

Note

In NCache, Write-through providers are configured on cache level, i.e., for clustered caches all nodes will contain provider configurations and their deployed assemblies.

Sample Implementation

The following code sample provides sample implementation for IWriteThruProvider interface for .NET and WriteThruProvider for Java respectively. The WriteToDataSource method contains logic to perform a write operation on a configured data source. Using this, you can write objects, bulk objects, and data types from the cache into the data source.

After implementing and deploying this provider, you can make direct calls to NCache for write operations on the data source. NCache uses the WriteToDataSource method in the specified data access class to write operations on data source.

// Contains methods used to save/update an object to the master data source.
public class SampleWriteThruProvider : IWriteThruProvider
{
    // Object used to communicate with the Data source.
    private SqlConnection _connection;

    // Perform tasks like allocating resources or acquiring connections
    public void Init(IDictionary parameters, string cacheId)
    {
        try
        {
            string connString = GetConnectionString(parameters);
            if (!string.IsNullOrEmpty(connString))
            {
                _connection = new SqlConnection(connString);
                _connection.Open();
            }
        }
        catch (Exception ex)
        {
            // Handle exception
        }
    }

    // Perform tasks associated with freeing, releasing, or resetting resources.
    public void Dispose()
    {
        if (_connection != null)
        {
            _connection.Close();
        }
    }

    //Responsible for write operations on data source
    public OperationResult WriteToDataSource(WriteOperation operation)
    {
        ProviderCacheItem cacheItem = operation.ProviderItem;
        Product product = cacheItem.GetValue<Product>();

        switch (operation.OperationType)
        {
            case WriteOperationType.Add:
                // Insert logic for any Add operation
                break;
            case WriteOperationType.Delete:
                // Insert logic for any Delete operation
                break;
            case WriteOperationType.Update:
                // Insert logic for any Update operation
                break;
        }
        // Write Thru operation status can be set according to the result.
        return new OperationResult(operation, OperationResult.Status.Success);
    }

    public ICollection<OperationResult> WriteToDataSource(ICollection<WriteOperation> operations)
    {
        var operationResult = new List<OperationResult>();
        foreach (WriteOperation operation in operations)
        {
            ProviderCacheItem cacheItem = operation.ProviderItem;
            Product product = cacheItem.GetValue<Product>();

            switch (operation.OperationType)
            {
                case WriteOperationType.Add:
                    // Insert logic for any Add operation
                    break;
                case WriteOperationType.Delete:
                    // Insert logic for any Delete operation
                    break;
                case WriteOperationType.Update:
                    // Insert logic for any Update operation
                    break;
            }
            // Write Thru operation status can be set according to the result
            operationResult.Add(new OperationResult(operation, OperationResult.Status.Success));
        }
        return operationResult;
    }

    public ICollection<OperationResult> WriteToDataSource(ICollection<DataTypeWriteOperation> operations)
    {
        var operationResult = new List<OperationResult>();
        foreach (DataTypeWriteOperation operation in operations)
        {
            var list = new List<Product>();
            ProviderDataTypeItem<object> cacheItem = operation.ProviderItem;
            Product product = (Product)cacheItem.Data;

            switch (operation.OperationType)
            {
                case DatastructureOperationType.CreateDataType:
                    // Insert logic for creating a new List
                    IList myList = new List<Product>();
                    myList.Add(product.ProductID);
                    break;
                case DatastructureOperationType.AddToDataType:
                    // Insert logic for any Add operation
                    list.Add(product);
                    break;
                case DatastructureOperationType.DeleteFromDataType:
                    // Insert logic for any Remove operation
                    list.Remove(product);
                    break;
                case DatastructureOperationType.UpdateDataType:
                    // Insert logic for any Update operation
                    list.Insert(0, product);
                    break;
            }
            // Write Thru operation status can be set according to the result.
            operationResult.Add(new OperationResult(operation, OperationResult.Status.Success));
        }
        return operationResult;
    }

    // Parameters specified in Manager are passed to this method
    // These parameters make the connection string
    private string GetConnectionString(IDictionary parameters)
    {
        string connectionString = string.Empty;
        string server = parameters["server"] as string, database = parameters["database"] as string;
        string userName = parameters["username"] as string, password = parameters["password"] as string;
        try
        {
            connectionString = string.IsNullOrEmpty(server) ? "" : "Server=" + server + ";";
            connectionString = string.IsNullOrEmpty(database) ? "" : "Database=" + database + ";";
            connectionString += "User ID=";
            connectionString += string.IsNullOrEmpty(userName) ? "" : userName;
            connectionString += ";";
            connectionString += "Password=";
            connectionString += string.IsNullOrEmpty(password) ? "" : password;
            connectionString += ";";
        }
        catch (Exception exp)
        {
            // Handle exception
        }
        return connectionString;
    }
    // Deploy this class on cache
}

public class SampleWriteThruProvider implements WriteThruProvider
{
    private Connection _connection;

    public void init(Map<String,String> parameters, String cacheId) {
        try {
            String connString = getConnectionString(parameters);

            if (connString.isEmpty()) {
                _connection.prepareStatement(connString);
                _connection.beginRequest();
            }
        } catch(Exception ex) {
            // Handle exception
        }
    }

    // Perform tasks associated with freeing, releasing, or resetting resources.
    public void close() {
        try {
            if (_connection != null) {
                _connection.close();
            }
        } catch(Exception ex) {
            // Handle exceptions
        }
    }

    //Responsible for write operations on data source
    public OperationResult writeToDataSource(WriteOperation operation) {
        try {
            String key = operation.getKey();

            ProviderCacheItem cacheItem = operation.getProviderCacheItem();
            Product product = cacheItem.getValue(Product.class);

            switch (operation.getOperationType()) {
                case Add:
                    // Insert logic for any Add operation
                    break;
                case Delete:
                    // Insert logic for any Delete operation
                    break;
                case Update:
                    // Insert logic for any Update operation
                    break;
            }
        } catch(Exception ex) {
            // handle exceptions
        }
        // Write Thru operation status can be set according to the result.
        return new OperationResult(operation,OperationResult.Status.Success);
    }

    public Collection<OperationResult> writeToDataSource(Collection<WriteOperation> collection) throws Exception {
        List<OperationResult> operationResults = new ArrayList<OperationResult>();

        for (WriteOperation writeOperation: collection) {
            String key = writeOperation.getKey();
            ProviderCacheItem cacheItem = writeOperation.getProviderCacheItem();
            Product product = cacheItem.getValue(Product.class);

            switch (writeOperation.getOperationType()) {
                case Add:
                    // Insert logic for any Add operation
                    break;
                case Delete:
                    // Insert logic for any Delete operation
                    break;
                case Update:
                    // Insert logic for any Update operation
                    break;
            }
            // Write Thru operation status can be set according to the result.
            operationResults.add(new OperationResult(writeOperation,OperationResult.Status.Success));
        }
        return operationResults;
    }

    public Collection<OperationResult> writeDataStructureToDataSource(Collection<DataStructureWriteOperation> operations) {
        var operationResult = new ArrayList<OperationResult>();
        try {
            for (DataStructureWriteOperation operation : operations) {
                var list = new ArrayList<Product>();
                ProviderDataStructureItem<Object> cacheItem = operation.getProviderItem();
                Product product = (Product) cacheItem.getData();

                switch (operation.getOperationType()) {
                    case CreateDataType:
                        // Insert logic for creating a new List
                        List myList = new ArrayList<Product>();
                        myList.add(product.getProductID());
                        break;
                    case AddToDataType:
                        // Insert logic for any Add operation
                        list.add(product);
                        break;
                    case DeleteFromDataType:
                        // Insert logic for any Remove operation
                        list.remove(product);
                        break;
                    case UpdateDataType:
                        // Insert logic for any Update operation
                        list.set(0,product);
                        break;
                }
                // Write Thru operation status can be set according to the result.
                operationResult.add(new OperationResult(operation,OperationResult.Status.Success));
            }
        } catch(Exception ex) {
            // handle exceptions
        }
        return operationResult;
    }

    private String getConnectionString(Map parameters) {
        String connectionString = null;
        try {
            String server = parameters.get("server").toString();
            String database = parameters.get("database").toString();
            String userName = parameters.get("username").toString();
            String password = parameters.get("password").toString();

            if (!server.isEmpty()) {
                connectionString = "Server=" + server + ";";
            } else {
                // Server name is empty
            }
            if (!database.isEmpty()) {
                connectionString = connectionString + "Database=" + database + ";";
            } else {
                // Database is empty
            }
            if (!userName.isEmpty()) {
                connectionString = connectionString + "User ID=" + userName + ";";
            } else {
                connectionString = connectionString + "User ID=" + "" + ";";
            }
            if (!password.isEmpty()) {
                connectionString = connectionString + "Password=" + password + ";";
            } else {
                connectionString = connectionString + "Password=" + "" + ";";
            }
        } catch (Exception e) {
            // handle exceptions
        }
        return connectionString;
    }
}

// Contains methods used to save/update an object to the master data source.
public class SampleWriteThruProvider : IWriteThruProvider
{
    // Object used to communicate with the Data source.
    private SqlConnection _connection;

    //Perform tasks like allocating resources or acquiring connections
    public void Init(IDictionary parameters, string cacheId)
    {
        object connStringObject = parameters["connstring"];
        string connString = connStringObject == null ? "" : connStringObject.ToString();

        if (connString != ""){
            _connection = new SqlConnection(connString);
        }

        try{
            _connection.Open();
        }
        catch (Exception ex){
          //handle exception
        }
    }

    //Perform tasks associated with freeing, releasing, or resetting resources.
    public void Dispose()
    {
        if (_connection != null)
            _connection.Close();
    }

    //Responsible for write operations on data source
    public OperationResult WriteToDataSource(WriteOperation operation)
    {
        Product product = (Product)operation.ProviderCacheItem.Value;

        SqlCommand command = new SqlCommand();
        command.Connection = _connection;

        if (operation.OperationType == WriteOperationType.Add){
          command.CommandText = "INSERT INTO Products(ID,Name)VALUES( '" + operation.Key + "','" + product.ProductName + "')";
        }

        if (operation.OperationType == WriteOperationType.Delete){
          command.CommandText = "DELETE FROM Products WHERE ID ='" + operation.Key + "'";
        }

        if (operation.OperationType == WriteOperationType.Update){
          command.CommandText = "UPDATE Products SET Name = '" + product.ProductName + "' WHERE ID='" + operation.Key + "'";
        }

        int result = command.ExecuteNonQuery();

        OperationResult operationResult = new OperationResult(operation,  OperationResult.Status.Success);

        if (result < 1){
            operationResult.DSOperationStatus = OperationResult.Status.Failure;
        }
      return operationResult;
    }

  public OperationResult[] WriteToDataSource(WriteOperation[] operations)
    {
        OperationResult[] operationResult = new OperationResult[operations.Length];

        SqlCommand command = new SqlCommand();
        command.Connection = _connection;

        int counter = 0;

        foreach (WriteOperation operation in operations){
            Product product = (Product)operation.ProviderCacheItem.Value;

            if (operation.OperationType == WriteOperationType.Add){
              command.CommandText = "INSERT INTO Products(ID,Name)VALUES( '" + operation.Key + "','" + product.ProductName + "')";
            }

            if (operation.OperationType == WriteOperationType.Delete){
                  command.CommandText = "DELETE FROM Products WHERE ID ='" + operation.Key + "'";
            }

            if (operation.OperationType == WriteOperationType.Update){
                  command.CommandText = "UPDATE Products SET Name = '" + product.ProductName + "' WHERE ID='" + operation.Key + "'";
            }

            int result = command.ExecuteNonQuery();

            operationResult[counter] = new OperationResult(operation, OperationResult.Status.Success);

            if (result < 1){
                operationResult[counter].DSOperationStatus = OperationResult.Status.Failure;
            }

            counter++;
        }
        return operationResult;
    }
}

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 sample application for Write-through on GitHub.

Write-through Cache Provider Configuration and Implementation

Warning

Note

Prerequisites

Note

Sample Implementation

Note

Additional Resources

See Also

Contact Us