Storing JSON, Custom Objects, and Data Structures in NCache

NCache, as an in-memory distributed cache enhances application performance and scalability by efficiently storing data in the cache. While it’s known for speeding up data access, it’s important to understand the types of data NCache can handle. Just as databases offer flexibility in storing various data types, NCache provides a range of options for storing JSON, custom objects, and complex data structures. This blog explores how NCache accommodates different data forms, ensuring you can optimize your caching strategy to meet your application’s specific needs.

Key-Value Pairs

NCache operates as a key-value store, where each piece of data is associated with a unique key (a string-based identifier), and has the following properties:

A key is supposed to be unique and no duplication is allowed.
A key cannot be null.
A key is case-sensitive.

The value represents the object stored in the cache, and we will explore the supported data types in detail later in the blog. Essentially, the key serves as the identifying attribute for the value stored against it. The figure below provides a visual representation of how data is added to and stored in the cache.

Figure: Data in NCache

Supported Data Types in NCache

NCache supports the data in the form of objects. These objects can be in any of the following forms:

Primitive and Non-primitive types
Custom Class Object
Data Structures
JSON Data

Primitive & Non-primitive Data Types

NCache supports all .NET primitive data types. You can add a string as a value against a key. The following are the types supported by NCache:

byte/sbyte
short/ushort
double
bool
int/uint
long/ulong
char
float
decimal

Non-primitive data types include:

object
string
TimeSpan
DateTime

Let us quickly walk through a brief code example showing the addition of a string against the key in the cache:

// Specify the customer name as string

string customerName = "John Wick";

// Generate a unique cache key

string key = "Customer";

// Add the string to cache

cache.Add(key, customerName);

Custom Class Object

A custom class object refers to any user-defined .NET or Java class, such as Product, Order, or Customer. To add a custom class object to your cache, it must be serializable. Serialization converts the class into a format suitable for storage and retrieval from the cache. You can achieve this in two ways:

Adding the .NET Serializable attribute in your custom class.
Using Dynamic Compact Serialization, a framework provided by NCache that offers cost-effective and dynamic serialization for registered classes.

Non-serialized data cannot be added to the cache. For detailed guidance on cache data serialization, refer to the Serialization section. Here’s how to add a serialized custom class object to the cache. Your class must be marked as serializable before proceeding with cache operations.

[Serializable]

public class Customer

{

public int CustomerID { get; set; }

public string CustomerName { get; set; }

public string CustomerAge { get; set; }

}

// Get customer from database

string customerKey = $"Customer:ALFKI";

Customer customer = FetchCustomerFromDB(customerKey);

// Get customer from database if not found in cache

if (customer == null)

{

// Get customer from database

customer = FetchCustomerFromDB("ALFKI");

cache.Add(customerKey, customer);

}

// Item added in cache successfully

Data Structures

NCache being distributed in nature supports data structures that allow the addition, removal, and retrieval of data without affecting the data consistency. Following are the data structures supported by NCache:

Distributed List: Native .NET implementation of the IList interface. The code below demonstrates creating a list of Product types in the cache using CreateList with the key ProductList and adding products to the list with the Add method

// Create list of Product type

IDistributedList<Product> list = cache.DataTypeManager.CreateList<Product>("ProductList");

// Add product to the List

list.Add(new Product)(){ Name = "Tofu", Category = "Food", UnitPrice = 0.15});

Distributed Queue: The first-in-first-out (FIFO) implementation for items is known as Distributed Queue. The code below demonstrates creating a queue of Candidate type in the cache with the key CandidateQueue and adding items to the queue.

// Create Queue of Candidate type

IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>("CandidateQueue");

// Add candidates to queue

queue.Enqueue(new Candidate(){ Name = "John Doe", Position = "Software Engineer" });

Distributed Hashset: An unordered datatype implementation where the values of a set are unique and distinctive. The code below creates a HashSet of int type in the cache using the CreateHashSet method for users logging in on Monday and then adding data to this HashSet.

// Create HashSets of int type

IDistributedHashSet<int> userSetMonday = cache.DataTypeManager.CreateHashSet<int>("MondayUsers");

// Add user IDs for Monday

userSetMonday.Add(1223);

userSetMonday.Add(34564);

Distributed Dictionary: A key-value pair that is a native .NET implementation of the IDictionary interface. The following code sample demonstrates creating a dictionary in the cache with the key ProductDictionary and adding data to it.

// Create dictionary of Product type

IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>("ProductDictionary");

// Add products

dictionary.Add(new Product(){ Name = "Laptop", Category = "Electronics", UnitPrice = 999.99 });

Distributed Counter: A data structure used to increment or decrement the value easily. The following code sample shows how to create a counter in the cache using the CreateCounter against the cache key SubscriptionCounter. It then further increments the value using the Increment method.

// Set initial value of counter

long initialValue = 15;

// Create counter

ICounter counter = cache.DataTypeManager.CreateCounter("SubscriptionCounter", initialValue);

// Increment value

long newValue = retrievedCounter.Increment();

You can use all these data structures as per your business logic. For more information on these data structures, refer to the NCache documentation.

JSON Data in NCache

JSON is a lightweight readable language used by applications for being extremely fast and compatible with all major JavaScript frameworks. NCache lets you add your JSON data easily in the cache-store by providing a few classes derived from a base class JsonValueBase as discussed below:

JsonObject: This class is for unordered name-value pairs where name is the name of the object and value is the value of the JSON object that can be of any primitive type.
JsonValue: This class represents the primitive data types in JSON’s conventions such as string, integer, or DateTime.
JsonArray: This class represents a collection of items and represents JArray in NCache’s domain.
JsonNull: This class represents a NULL value in JSON

The following example shows how to retrieve a JsonObject as a custom object.

// Create a new JsonObject with the following attributes in the string

string jsonString = $@"{{

""CustomerID"": ""1"",

""ContactName"": ""David Johnes"",

""CompanyName"": ""Lonesome Pine Restaurant"",

""Phone"": ""12345 - 6789"",

""Address"": ""Silicon Valley, Santa Clara, California""

}}";

// Retrieve the JsonObject from the string

JsonObject customer = new JsonObject(jsonString);

// Create a unique key for this object

string key = "CustomerID:1001";

// Insert JsonObject in the cache

cache.Insert(key, customer);

// Get the JsonObject as a custom object

object retrievedItem = cache.Get<Customer>(key);

if (retrievedItem != null)

{

// Perform operations according to business logic

}

else

{

// No such item exists

}

Location Affinity

An added feature of NCache that enhances performance is Location Affinity. This feature allows you to keep data from different classes on the same node, creating an affinity between items and reducing the cost of fetching them. To achieve this, you can group items with similar affinities using braces {}, ensuring they reside on the same node. For instance, Order_{Customer:1001}, shows affinity between the orders belonging to the customer object with the customer key 1001.

Here’s a code example demonstrating how to use Location Affinity to add Customer and Order on the same node:

Customer customer = FetchCustomerFromDB(1001);

string customerKey = "Customer:1001";

var customerCacheItem = new CacheItem(customer);

// Add CacheItem to cache

cache.Add(customerKey, customerCacheItem);

Order order = FetchOrderFromDB(1001);

// Unique orderKey for this order using location affinity syntax

// This will create an affinity for this orderKey with the respective customerKey

string orderKey = "Order_{"+ customerKey +"}";

var orderCacheItem = new CacheItem(order);

// Add order with location affinity to the cache

cache.Add(orderKey, orderCacheItem);

Conclusion

To conclude our discussion, NCache provides flexible ways to add data into the cache catering to your application’s requirements. All you need to do is use a simple API to add the data to the cache. The best part about NCache is that with every new version, along with the support for new features and enhancements, data addition becomes easier and more efficient. To explore the exciting features that NCache provides, download NCache today!