Multiple cache keys for single object

[ivann14]

Hello,

I would like to ask, how do you solve a scenario in which, you have entity e.g. User(int id, Guid guid, string email, etc...) and it can be fetched via multiple identifiers Id/Guid/Email. I see some options but I do not like either of them, can you steer me in right direction?

By the way User's Id/Guid/Email cannot be changed.
I would start only with in-memory caching for starters.

Option 1: Get it and then set it with different keys
I feel like that this is not great. What if another thread updates user and invalidates the cache before we set it under different cache keys

public User GetUserById(int id) 
{
   var user = cache.GetOrSet<User>($"userById:{id}",_ => GetFromDbById(id))
   cache.Set($"userByGuid:{user.Guid}", user)
   cache.Set($"userByEmail:{user.Email}", user)
    return user;
}

public User GetUserByGuid(Guid guid) 
{
   var user = cache.GetOrSet<User>($"userByGuid:{guid}",_ => GetFromDbByGuid(guid))
   cache.Set($"userById:{user.Id}", user)
   cache.Set($"userByEmail:{user.Email}", user)
    return user;
}

public User GetUserByEmail(string email) 
{
   var user = cache.GetOrSet<User>($"userByEmail{email}",_ => GetFromDbByEmail(email))
   cache.Set($"userById:{user.Id}", user)
   cache.Set($"userByGuid:{user.Guid}", user)
    return user;
}

Option 2:
Dunno why but this just does not feel right

public User GetUserById(int id) 
{
   return cache.GetOrSet<User>($"userById:{id}",_ => 
   { 
      var dbUser = GetFromDbById(id));
      cache.Set($"userByGuid:{dbUser.Guid}", dbUser);
      cache.Set($"userByEmail:{dbUser.Email}", dbUser);
   }
}

public User GetUserByGuid(Guid guid) 
{
   return cache.GetOrSet<User>($"userByGuid:{guidl}",_ => 
   { 
      var dbUser = GetFromDbByGuid(guid));
      cache.Set($"userById:{dbUser.Id}", dbUser);
      cache.Set($"userByEmail:{dbUser.Email}", dbUser);
   }
}

public User GetUserByEmail(string email) 
{
   return cache.GetOrSet<User>($"userByEmail:{email}",_ => 
   { 
      var dbUser = GetFromDbByEmail(email));
      cache.Set($"userById:{dbUser.Id}", dbUser);
      cache.Set($"userByGuid:{dbUser.Guid}", dbUser);
   }
}

Option 3:
Just not overthinking it

public User GetUserById(int id) 
   => cache.GetOrSet<User>($"userById:{id}",_ => GetFromDbById(id));

public User GetUserByGuid(Guid guid) 
   => cache.GetOrSet<User>($"userByGuid:{guid}",_ => GetFromDbByGuid(guid));

public User GetUserByEmail(string email) 
   => cache.GetOrSet<User>($"userByEmail:{email}",_ => GetFromDbByEmail(email));

Thank you for help

[jodydonetti]

Hi @ivann14 sorry for being late, I somehow missed this.

In general, if possible, I tend to have only one "canonical" cache entry for each object, in this case the user.
To do that one idea may be to pick the main way to identify a user, let's say it's the guid, and for the other 2 you would cache a lookup structure or the guid itself, and then load the user via guid.

In this way an update to a user will be reflected immediately for whatever lookup you'll end up using (via guid, via id or via email), and you'll store in cache only one copy of each user.

Something like this:

public User GetUserByGuid(Guid guid) {
  return cache.GetOrSet<User>($"userByGuid:{guid}",_ => GetFromDbByGuid(guid));
}

public User GetUserById(int id) {
  var guid = cache.GetOrSet<Guid>($"userGuidById:{id}",_ => GetFromDbById(id)?.Guid);
  return GetUserByGuid(guid); // THIS WILL STILL USE THE CACHE VIA THE GetUserByGuid
}

public User GetUserByEmail(string email) {
  var guid = cache.GetOrSet<Guid>($"userGuidByEmail:{email}",_ => GetFromDbByEmail(email)?.Guid);
  return GetUserByGuid(guid); // THIS WILL STILL USE THE CACHE VIA THE GetUserByGuid
}

Thoughts?

Hope this helps.

[ivann14]

Ok, thank you for the insight.

I did not really wanted to mention this as an option because I felt that there are "too many DB roundtrips" and I wanted to keep them at minimum, but those cache misses will be rare and invalidation will become much easier.

[jodydonetti]

I did not really wanted to mention this as an option because I felt that there are "too many DB roundtrips" and I wanted to keep them at minimum, but those cache misses will be rare and invalidation will become much easier.

Yeah I feel that in the grand scheme of things and all things considered, including how lookups can be cached for a long time, it will not be an issue.

FWIW I've personally used a similar approach in production on a system that was quite big (not petascale, but still millions of cached entries).

[jodydonetti]

Another thing to consider as a potential optimization is this:

private User GetUserByGuid(Guid guid, User? user) {
  return cache.GetOrSet<User>($"userByGuid:{guid}",_ => user ?? GetFromDbByGuid(guid));
}

public User GetUserByGuid(Guid guid) {
  return GetUserByGuid(guid, null));
}

public User GetUserById(int id) {
  User? user = null;
  var guid = cache.GetOrSet<Guid>($"userGuidById:{id}",_ => (user = GetFromDbById(id))?.Guid);
  return GetUserByGuid(guid, user); // THIS WILL STILL USE THE CACHE VIA THE GetUserByGuid
}

public User GetUserByEmail(string email) {
  User? user = null;
  var guid = cache.GetOrSet<Guid>($"userGuidByEmail:{email}",_ => (user = GetFromDbByEmail(email))?.Guid);
  return GetUserByGuid(guid, user); // THIS WILL STILL USE THE CACHE VIA THE GetUserByGuid
}

In this way the loading of a user will never be wasted.

An extra final thing to play with is to always set the 2 cache entries for the lookups when loading a user: since you just loaded it, you can already save the 2 lookups which may be needed in the future, so everything will be ready to go.

Hope this helps.

[ivann14]

Thank you for your help, much appreciated.
This one is great, really simple and effective.