Serializing Custom .Net Types for use with the Azure Redis Cache

In my previous post I looked at a real-world example of using the new Azure Redis Cache. One thing that was missing was the storing of custom .Net Types as cache values, which we’ll look at here.

The RedisValue Type

The Microsoft Azure documentation recommends using the StackExchange.Redis API for accessing the Redis Cache. This API stores cache values within the RedisValue type, which has a number of implcit conversions from primitive .Net types (Int32, Int64, Double, Boolean etc.), but conversions from the RedisValue type to the primitive .Net type need to be made explicitily.

For example, setting an int as the cache value is implicit, while retrieving an int from a cache value needs to be cast (the following screenshot is from the MSDN documentation):

In addition to the implicit/explicit conversion of primitive data types, the RedisValue type can store binary data as the cache value. This means that we can serialize a custom .Net type into a byte array and pass that as the cache value within the StringSet() method; we can then retrieve that cache value using the StringGet() method and deserialize the byte array back to the custom type.

To complete the serialization/deserialization, we need a helper class, which is shown below. This class is inspired by the sample on MSDN (Work with .Net objects in the cache) but is tweaked slightly:

	/*
	* A simple generic Serialization Helper allowing custom .Net types to be stored
	* in the Azure Redis Cache. Inspired by the sample at:
	* http://msdn.microsoft.com/en-us/library/azure/dn690524.aspx#Objects
	*/
	using System.IO;
	using System.Runtime.Serialization.Formatters.Binary;
	namespace AzureRedisCacheSample
	{
	public static class CacheSerializer
	{
	public static byte[] Serialize(object o)
	{
	if (o == null)
	{
	return null;
	}
	BinaryFormatter binaryFormatter = new BinaryFormatter();
	using (MemoryStream memoryStream = new MemoryStream())
	{
	binaryFormatter.Serialize(memoryStream, o);
	byte[] objectDataAsStream = memoryStream.ToArray();
	return objectDataAsStream;
	}
	}
	public static T Deserialize<T>(byte[] stream)
	{
	if (stream == null)
	return (default(T));
	BinaryFormatter binaryFormatter = new BinaryFormatter();
	using (MemoryStream memoryStream = new MemoryStream(stream))
	{
	T result = (T)binaryFormatter.Deserialize(memoryStream);
	return result;
	}
	}
	}
	}

view raw

AzureRedisCache-CacheSerializer.cs

hosted with ❤ by GitHub

Note that during deserialization, if the byte array is null, a default instance of type T will be returned. This caught me out when I was initially testing, so beware that it is returning the value you expect.

Using these helpers with the StackExchange.Redis API’s StringSet() and StringGet() methods to store custom .Net types makes life really easy:

	var cacheItem = CacheSerializer.Deserialize<Guid>(cache.StringGet(cacheKey));
	if (cacheItem == Guid.Empty)
	{
	// Cache item doesn't exist, retrieve Guid from source system.
	// Add (serialized) Guid to the Azure Redis Cache with a lifespan of 90 minutes
	cache.StringSet(cacheKey, CacheSerializer.Serialize(cacheItem), TimeSpan.FromMinutes(90));
	}

view raw

AzureRedisCache-CacheGetSetWithSerialization.cs

hosted with ❤ by GitHub

To retrieve a custom type, we call the StringGet() method, passing the cache Key and deserialize the returned byte array into the .Net Guid type; In order to determine whether the cache item was found, I check whether the returned cacheItem equals Guid.Empty, which is the value returned by default(T) for the Guid type from the Deserialize() method.

To store a custom .Net type (in this case a GUID), call the StringSet() method and instead of passing a primitive type as the cache value, we serialize our cache item and pass the resulting byte array.