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:
WriteThru
updates data in the data source synchronously after updating the cache-store.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.
Important
For Java, before deploying your JAR files, you need to make sure that:
- JDK 17 is installed.
- The environment variable for Java is set.
Prerequisites for Using Write Through
- 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.
// 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.
// 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.
// 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.
// 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.
// 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.
// 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.
// 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.
Java: com.alachisoft.ncache.runtime.datasourceprovider namespace.