Using Write-through with Cache Operations

This section explains the use of the Write-through provider after configuring and deploying it. NCache provides the Alachisoft.NCache.Runtime.Caching.WriteThruOptions class to specify WriteThru options in APIs. The WriteThruOptions class contains

1. WriteThru updates data in the data source synchronously after updating the cache-store.
2. WriteBehind updates data in the data source asynchronously after updating the cache-store.

Multiple Write-through providers can be configured through NCache. Default Write-through provider will be called if a specific provider name is not mentioned through API. You can also use providers other than default by using provider-specific overloads of APIs.

Prerequisites for Using Write-through

• .NET
• Legacy API

• To learn about the standard prerequisites required to work with all NCache server-side features please refer to the given page on Server Side API Prerequisites.
• For API details refer to: ICache, CacheItem, Get, Insert, InsertAsync, Remove, RemoveAsync, IWriteThruProvider.

Add/Update with Write-through

The following example creates a new cacheItem and adds this item in the cache with Write-through enabled, using the Insert() method. Using this method if the item is already present in the cache, the old value will be over-written with the new value.

• .NET

// Pre-Condition: Cache is already connected

// Fetch product with the given ProductID
Product product = FetchProductByProductID(1001);

// Specify the key of the item
string key = $"product.ProductID";
product.UnitPrice = 200;

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

// Enable Write-through for the cacheItem created
var writeThruOptions = new WriteThruOptions();
writeThruOptions.Mode = WriteMode.WriteThru;

// Add the item in the cache with WriteThru enabled
CacheItemVersion itemVersion = cache.Insert(key, cacheItem, writeThruOptions);

Note

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

Bulk Operations

Add/Update Bulk Items with Write-through

The following example adds bulk items in the cache with Write-through enabled, using the InsertBulk() method. If the items are already present in the cache, new values overwrite the existing values.

• .NET

// Fetch all products from database
Product[] products = FetchProductsFromDB();

var writeThruOptions = new WriteThruOptions();
writeThruOptions.Mode = WriteMode.WriteThru;

IDictionary<string, CacheItem> dictionary = new Dictionary<string, CacheItem>();
foreach(var product in products)
{
  string key = $"Product:{product.ProductID}";
  var cacheItem = new CacheItem(product);
  dictionary.Add(key, cacheItem);
}

IDictionary<string, Exception> keysFailedToUpdate = cache.InsertBulk(dictionary, writeThruOptions);

Remove Items in Bulk with Write-through

The following example removes a bulk of items from the cache with Write-Behind enabled, using the RemoveBulk() method.

• .NET

// Get Keys
Product[] products = FetchProductsFromDB();

// Specify keys to remove from cache
string[] keys = new string[products.Length];
int index = 0;

foreach (var product in products)
{
  keys[index] = $"Product:{product.ProductID}";
  index++;
}

// Create dictionary to store removed items
IDictionary<string, Product> removedItems = new Dictionary<string,Product>();

// Configure write thru
var writeThruOptions = new WriteThruOptions();
writeThruOptions.Mode = WriteMode.WriteThru;

// Remove items with write-behind enabled
cache.RemoveBulk(keys, out removedItems, writeThruOptions);

Note

Use the method OnDataSourceItemsRemoved() to perform operations after data removal.

Remove an Existing Item with Write-through

The following example removes an item from the cache with Write-through enabled, using the Remove() method.

• .NET
• Legacy API

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

// Enable Write-through for the cacheItem created
var writeThruOptions = new WriteThruOptions();
writeThruOptions.Mode = WriteMode.WriteThru;

// Remove the item corresponding to the key with Write-through enabled
cache.Remove(key, null, null, writeThruOptions);

Asynchronous Operations

Add/Update Item with Write-through

The following example adds an item asynchronously in the cache with Write-through enabled, using the InsertAsync() method.

• .NET

// Get product from database against given product ID
Product product = FetchProductFromDB(1001);

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

var cacheItem = new CacheItem(product);

// Enable write behind for the cacheItem created
var writeThruOptions = new WriteThruOptions();
writeThruOptions.Mode = WriteMode.WriteThru;

// Add Product object to cache
Task task = cache.InsertAsync(key, cacheItem, writeThruOptions);

Remove Item with Write-through

The following example removes existing items asynchronously from the cache with Write-through enabled, using the RemoveAsync() method.

• .NET

// Unique cache key of product to remove
string key = $"Product:{product.ProductID}";

// Enable write behind for the cacheItem created
var writeThruOptions = new WriteThruOptions();
writeThruOptions.Mode = WriteMode.WriteThru;

// Asynchronously remove items from cache
Task<Product> task = cache.RemoveAsync<Product>(key, writeThruOptions);

Use Data Structures with Write-through

The following example uses different data structures with Write-through enabled, on the specified item.

• .NET

// Specify the key of the item
string key = $"Product:{product.ProductID}";
var dataTypeAttributes = new DataTypeAttributes();
var writeThruOptions = new WriteThruOptions(WriteMode.WriteThru, WriteThruProviderName);

switch(mainMenu)
{
  case mainMenu.GetDistributedCounter:
    // Modify or add count of the corresponding item with write thru enabled
    var distributedCounter = cache.DataTypeManager.CreateCounter("counter", dataTypeAttributes, 0, writeThruOptions);

    // perform operations on counter
    break;
  case mainMenu.GetDistributedDictionary:
    // Modify or add dictionary of the corresponding item with write thru enabled
    var distributedDictionary = cache.DataTypeManager.CreateDictionary<string, int>(key, dataTypeAttributes, writeThruOptions);

    // perform operations on dictionary
    break;
  case mainMenu.GetDistributedList:
    // Modify or add the list of the corresponding item with write thru enabled
    var distributedList = cache.DataTypeManager.CreateList<int>("list", dataTypeAttributes, writeThruOptions);

    // perform operations on list
    break;
  case mainMenu.GetDistributedQueue:
    // Modify or add the queue of the corresponding item with read thru enabled
    var distributedQueue = cache.DataTypeManager.CreateQueue<int>("queue", dataTypeAttributes, writeThruOptions);

    // perform operations on queue
    break;
  case mainMenu.GetDistributedHashSet:
    // Modify or add the HashSet of the corresponding item with read thru enabled
    var distributedHashSet = cache.DataTypeManager.CreateHashSet<int>("hashset", dataTypeAttributes, writeThruOptions);

    // perform operations on hashset
    break;
}

Additional Resources

NCache provides sample application for Write-through on GitHub.

See Also

.NET: Alachisoft.NCache.Runtime namespace.