Using a GUID for a cache key is not a good solution, as you have already discovered. The main problem is that after the GUID is generated, there is no way to reliably regenerate it into the same key in order to get the data out of the cache.
Usually, when I create a cache the keys are based off of the entity being cached or the method that is caching it. But it is also possible to make the cache based on a combination of values that together make the value unique.
Example Using Entity
public class Employee
{
int Id { get; set; }
string Name { get; set; }
}
To get the key from an entity, we simply use a constant value in addition to the primary key of the entity.
private const string KEY_PREFIX = "Employee_";
private object syncLock = new object();
// innerEmployeeRetriever and cache are populated through the constructor
public Employee GetEmployee(int id)
{
string key = KEY_PREFIX + id.ToString();
// Get the employee from the cache
var employee = cache[key];
if (employee == null)
{
lock (syncLock)
{
// Double-check that another thread didn't beat us
// to populating the cache
var employee = cache[key];
if (employee == null)
{
employee = innerEmployeeRetriever.GetEmployee(id);
cache[key] = employee;
}
}
}
return employee;
}
Example Using Method Name
private object syncLock = new object();
// innerEmployeeRetriever and cache are populated through the constructor
public Employee GetEmployeeList()
{
string key = "GetEmployeeList";
// Get the employee from the cache
var employees = cache[key];
if (employees == null)
{
lock (syncLock)
{
// Double-check that another thread didn't beat us
// to populating the cache
var employees = cache[key];
if (employees == null)
{
employees = innerEmployeeRetriever.GetEmployeeList();
cache[key] = employees;
}
}
}
return employees;
}
Example Using a Combination of Values
You can also build the keys from several different values that in combination make the entity unique. This is helpful if you don't have a primary key to work with or you have several different contexts that you want to cache separately. This example was taken from MvcSiteMapProvider:
protected string GetCacheKey(string memberName)
{
// NOTE: We must include IsReadOnly in the request cache key
// because we may have a different
// result when the sitemap is being constructed than when
// it is being read by the presentation layer.
return "__MVCSITEMAPNODE_" + this.SiteMap.CacheKey + "_" + this.Key
+ "_" + memberName + "_" + this.IsReadOnly.ToString() + "_";
}
In this case, we are building the key based on the unique key of the parent SiteMap the node belongs to, the unique key of the node, the method or property name, and whether or not the readonly flag is currently set. Each unique set of these values results in a separate cache key, making a separate cache for each combination.
Of course, for this to work right, there should be some kind of "safe" delimiter between the values to prevent the same key from being created by concatenating different values. For example, "1" + "23" is the same string as "12" + "3", but you can prevent these sort of collisions by using an underscore, pipe character, comma, or some other delimiter that won't be in the data itself to separate the values ("1" + "_" + "23" is not the same string as "12" + "_" + "3").
The bottom line is that the cache key must somehow represent what is in the cache in order for it to be useful. Your application should understand how to provide the data that makes up the key so it can be re-made if the same data needs to be retrieved again.
