Update/Insert Existing Data in Cache

NCache provides the Insert method and its overloads to facilitate updating objects in the cache. While it overwrites data for existing items, it also adds the item to the cache if the key does not exist in the cache.

Prerequisites

To learn about the standard prerequisites required to work with all NCache client-side features, please refer to the given page on Client-Side API Prerequisites.
For API details, refer to: ICache, CacheItemVersion, CacheItem, Insert, Get, InsertBulk, InsertAsync.

Update Object in Cache

Note

This feature is also available in NCache Professional.

You can update a custom object in the cache using various overloads of the Insert method. This returns a CacheItemVersion.

Important

If the key already exists, it will overwrite the existing cache item with the same key.
If the key does not exist, the operation adds the item to the cache instead.

Note

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 example gets the values of an existing object and inserts it against the same key into the cache. If the key does not exist, it adds it to the cache.

// Precondition: Cache is already connected

string customerKey = "ALFKI";

// Get updated product from database against given product ID
Customer customer = FetchProductFromDB("ALFKI");

// Insert Product object to cache
CacheItemVersion version = cache.Insert(customerKey, customer);

// Item updated in cache successfully

// Precondition: Cache is already connected

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

// Insert Product object to cache
CacheItemVersion version = cache.insert("1001", product);

// Item updated in cache successfully

# Precondition: Cache is already connected

# Get product from database against given product ID
product = fetch_product_from_db()

# Generate a unique cache key for this product
key = "Product:" + product.get_product_id()

# Insert Product object to cache
version = cache.insert(key, product)

# Item inserted in cache successfully

// Precondition: Cache is already connected

// Get product from database against given product ID
product = await this.fetchProductFromDB();

// Generate a unique cache key for this product
var key = "Product:" + product.getProductID();

// insert Product object to cache
var version = await this.cache.insert(key, product);

// Item added in cache successfully

Update Object With Expiration

Note

This feature is also available in NCache Professional.

CacheItem is a custom class provided by NCache that can be used to add data to the cache and also lets you set additional specifications associated with an object as properties of this class. The CacheItem is updated in the cache against a unique key.

Important

If the key already exists, it will overwrite the existing cache item with the same key.
If the key does not exist, the operation adds the item to the cache instead.

The following example gets updated values of an existing CacheItem and inserts it against the same key into the cache. If the key does not exist, it adds it to the cache.

string customerKey = $"Customer:ALFKI";
Customer customer = FetchCustomerFromDB("ALFKI");

// Update Customer's Phone
customer.Phone = "0921-12 34 65";

// Create CacheItem
CacheItem cacheItem = new CacheItem(customer);
cacheItem.Expiration = new Expiration(ExpirationType.Sliding, TimeSpan.FromMinutes(5));

// Update cutsomer in DB and Cache
if (UpdateDB(customer))
{
    cache.Insert(customerKey, cacheItem);
}

String customerKey = "ALFKI";

// Get the customer from the database
Customer customer = fetchCustomerFromDB(customerKey);

// Update Customer's Phone
customer.setPhone("0921-12 34 65");

// Create CacheItem
CacheItem cacheItem = new CacheItem(customer);
cacheItem.setExpiration(new Expiration(ExpirationType.Sliding, TimeSpan.FromMinutes(5)));

// Update customer in DB and Cache
cache.insert(customerKey, cacheItem);
System.out.println("Customer updated in cache successfully");

# Get product from database against given product ID
product = fetch_product_from_db()

# Generate a unique cache key for this product
key = "Product:" + product.get_product_id()

# Create a new CacheItem for this product
# You can OPTIONALLY specify multiple properties e.g.Priority, Expiration
# These properties are explained in successive chapters
cache_item = ncache.CacheItem(product)

# Insert CacheItem to cache
version = cache.insert(key, cache_item)

// Get product from database against given product ID
product = await this.fetchProductFromDB();

// Generate a unique cache key for this product
var key = "Product:" + product.getProductID();

// Create a new CacheItem for this product
// You can OPTIONALLY specify multiple properties e.g. Priority, Expiration
// These properties are explained in successive chapters
var cacheItem = new ncache.CacheItem(product);

// insert CacheItem to cache
var version = await this.cache.insert(key,cacheItem);

Update Bulk Items in Cache

Note

This feature is also available in NCache Professional.

InsertBulk updates an array of CacheItem to the cache against the corresponding key. The method returns a dictionary of all the keys that failed to update, along with the failure reason.

Important

If any keys fail to update, their reasons of failure will be returned as an IDictionary.

The following code example fetches an array of products (of Customer type) from the database. The products are then inserted to the cache as a dictionary of keys and CacheItem using InsertBulk.

// Create an array of all Customer Keys
String[] keys = new String[]
{
    "Customer:ALFKI", "Customer:ANATR", "Customer:ANTON", "Customer:AROUT", "Customer:BERGS"
};

// Get items from cache
IDictionary<string, Customer> itemsFetched = cache.GetBulk<Customer>(keys);

//Create a dictionary to store updated items
IDictionary<string, CacheItem> itemsUpdated = new Dictionary<string, CacheItem>();

// Update postal codes of dictionary items
foreach (KeyValuePair<string, Customer> item in itemsFetched)
{
    //Update Postal Code
    item.Value.PostalCode = "05023";

    // Create CacheItem of updated Customer object
    CacheItem updatedCacheItem = new CacheItem(item.Value);

    // Add uCacheItem to dictionary
    itemsUpdated.Add(item.Key,updatedCacheItem);
}

if (UpdateDB(itemsUpdated))
{
    // Insert updated bulk items to Cache
    IDictionary<string, Exception> keysFailedToInsert = cache.InsertBulk(itemsUpdated);

    if (keysFailedToInsert.Count > 0)
    {
        foreach (KeyValuePair<string, Exception> keyFailedToInsert in keysFailedToInsert)
            Console.WriteLine($"Could not update Item {keyFailedToInsert.Key} in cache due to error : {keyFailedToInsert.Value}");
    }
}

// Create an array of all Customer Keys
List<String> keys = List.of(
        "Customer:ALFKI",
        "Customer:ANATR",
        "Customer:ANTON",
        "Customer:AROUT",
        "Customer:BERGS"
);

// Get items from cache
Map<String, Customer> itemsFetched = cache.getBulk(keys, Customer.class);

//Create a dictionary to store updated items
Map<String, CacheItem> itemsUpdated = new HashMap<>();

// Update postal codes of dictionary items
for (Map.Entry<String, Customer> item : itemsFetched.entrySet()) {
    //Update Postal Code
    item.getValue().setPostalCode("05023");

    // Create CacheItem of updated Customer object
    CacheItem updatedCacheItem = new CacheItem(item.getValue());

    // Add uCacheItem to dictionary
    itemsUpdated.put(item.getKey(), updatedCacheItem);
}

if (updateDB(itemsUpdated)) {
    // Insert updated bulk items to Cache
    Map<String, Exception> keysFailedToInsert = cache.insertBulk(itemsUpdated);

    if (keysFailedToInsert.size() > 0) {
        for (Map.Entry<String, Exception> keyFailedToInsert : keysFailedToInsert.entrySet()) {
            System.out.printf("Could not update Item %s in cache due to error : %s", keyFailedToInsert.getKey(), keyFailedToInsert.getValue());
        }
    }
}

# Fetch all products from database
products = fetch_products_from_db()

# Create map of items to be inserted to cache
dictionary = {}

for product in products:
    key = "Product:" + product.get_product_id()
    cache_item = ncache.CacheItem(product)

    # Add items to dictionary
    dictionary[key] = cache_item

keys_failed_to_insert = cache.insert_bulk(dictionary)

if len(keys_failed_to_insert) > 0:
    for entry in keys_failed_to_insert:
        if not keys_failed_to_insert[entry]:
            value = False
else:
    # Any other exception
    value = True

// Fetch all products from database
var products = await this.fetchProductFromDB();

//Create map of items to be added to cache
var dictionary = new Map();

products.forEach(prod => {
    var key = "Product:" + this.product.getProductID();
    var cacheItem = new ncache.CacheItem(this.product);

    //insert dictionary to cache
    this.cache.insert(key,cacheItem);
});

var keysFailedToAdd = this.cache.addBulk(dictionary);

if(keysFailedToAdd.size() > 0)
{
    keysFailedToAdd.forEach(entry => {
        if(entry.getValue() == false)
        {
            var ex = false;
        }
        else
        {
            // Any other exception
        }
    });
}

Update Objects with Asynchronous API

InsertAsync returns the object of the Task class which can further be used according to the business needs of the client application.

string customerKey = $"Customer:ALFKI";

// Get customer from database if not found in cache
if (customer == null)
    customer = FetchCustomerFromDB("ALFKI");

// Update customer's Phone
customer.Phone = "12345-6789";

// Update cutsomer in DB and Cache
if (UpdateDB(customer))
{
    // Adding item asynchronously.
    Task<CacheItemVersion> task = cache.InsertAsync(customerKey, customer);

    // This task object can be used as per your business needs
    if (task.IsCompleted)
    {
        // Get CacheItemVersion object from task result
        CacheItemVersion version = task.Result;
        Console.WriteLine($"Item {customer.CustomerID} has been updated with verion {version.Version}.");
    }
}

String customerKey = "Customer:ALFKI";

// Get customer from database if not found in cache
if (customer == null)
Customer customer = fetchCustomerFromDB("Customer:ALFKI");

// Update customer's Phone
customer.setPhone("12345-6789");

// Update cutsomer in DB and Cache
if (updateDB(customer)) {
    // Adding item asynchronously.
    FutureTask<CacheItemVersion> task = cache.insertAsync(customerKey, customer);

    // Wait for task to complete and get CacheItemVersion object from task result
    CacheItemVersion version = task.get();
    System.out.println("Item " + customer.getCustomerID() + " has been updated with version " + version.getVersion() + ".");
}

# Get product from database
product = fetch_product_from_db()

# Generate a unique cache key for this product string
key = f"Product:{product.get_product_id()}"

# Insert Product object to cache asynchronously
async def insert_async():
    task = cache. insert_async("key", "product")
    value = await task

asyncio.run(insert_async())

# This task object can be used as per your business needs

Additional Resources

NCache provides a sample application for Basic Operations on GitHub.

Update/Insert Existing Data in Cache

Prerequisites

Update Object in Cache

Note

Important

Note

Update Object With Expiration

Note

Important

Update Bulk Items in Cache

Note

Important

Update Objects with Asynchronous API

Additional Resources

See Also

Contact Us