Get objects by value out of cache

Question

Abstract

I am writing an application which has a few object caches. The way it needs to work is when an object is retrieved from the cache:

object foo = CacheProvider.CurrentCache.Get("key");

foo should be a local copy of the original object, not a reference. What is the best way to implement this? The only way I have in mind so far is to use a BinarySerializer to create a copy, but I feel like I am missing a better way.

Details

The backing for the cache implementation is arbitrary, as it is provider-based. I need to support any number of caches, from the HttpRuntime cache to something like Velocity. The focus here is on the layer between the cache backing and the consumer code - that layer must ensure a copy of the object is returned. Some caches will already do this, but some do not (HttpRuntime cache being one).

Answer 1

Sorry, I must be underthinking this. Why not lookup the objects in a dictionary and then create a deep copy of the object (e.g., IDeepCopyable) or use reflection to do the job?

Roughly:

public interface IDeepCopyable {
    object DeepCopy();
}

public class Cache<TKey, TValue> where TValue : IDeepCopyable {
    Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>();

    // omit dictionary-manipulation code

    public TValue this[TKey key] {
        get {
            return dictionary[key].DeepCopy(); // could use reflection to clone too
        }
    }
}

If you go the reflection route, Marc Gravell has some nice cloning code easily modified to make a deep copy.

Answer 2

Rex - we implemented something very similar in a big enterprise web product, and we ended up explicitly creating an IDeepCloneable interface that many of our objects implemented. The interesting thing is that we backed it with BinarySerializer, simply because it's a convienent and virtually foolproof way to make a deep copy of an object without all the hassle of reflection or forcing developers to write and test clone methods.

It works like a charm. Our team has stopped to mull over it several times and we have yet to come up with a better option.

Answer 3

Here is a simple function that will use reflection to deep copy and object, regardless of type. I culled this, in part from a much more complex copy routine I used in the old Web Services days to copy between Nearly Identical(tm) data types. It might not work exactly, bit it gives you the general idea. It is very simplistic and when using raw reflection there are many boundary cases...

public static object ObjCopy(object inObj)
{
    if( inObj == null ) return null;
    System.Type type = inObj.GetType();

    if(type.IsValueType)
    {
     return inObj;
    }
    else if(type.IsClass)
    {
     object outObj = Activator.CreateInstance(type);
     System.Type fieldType;
     foreach(FieldInfo fi in type.GetFields())
     {
      fieldType = fi.GetType();
      if(fieldType.IsValueType) //Value types get copied
      {
       fi.SetValue(outObj, fi.GetValue(inObj));
      }
      else if(fieldType.IsClass) //Classes go deeper
      {
       //Recursion
       fi.SetValue(outObj, ObjCopy(fi.GetValue(inObj)));
      }
     }
     return outObj;
    }
    else
    {
     return null;
    }
}

Personally, I would use the Serializer routines, since they automatically handle all the boundary cases. By default, at least in .NET 2.0, the system dynamically creates the Serialization assembly. You can speed up Serialization by caching the Serializers. This sample code from my app is caching the XmlSerializers.

protected static XmlSerializer SerializerGet(System.Type type)
{
    XmlSerializer output = null;
    lock(typeof(SerializeAssist))
    {
     if(serializerList.ContainsKey(type))
     {
      output = serializerList[type];
     }
     else
     {
      if(type == typeof(object) || type == typeof(object[]) || type == typeof(ArrayList))
      {
       output = new XmlSerializer(type, objArrayTypes);
      }
      else
      {
       output = new XmlSerializer(type);
      }
      serializerList.Add(type, output);
     }
    }
    return output;
}