C#

// Some type a user of the framework wants to store persistently.
public class Toto
{
   int n;
   string s;
   Toto parent;

   // .. other members that we don't really care about; only fields matter.
}


public class Storage
{
   // Storage itself doesn't really have a clue how anything is stored, 
   // but it knows about an object that can generate implementations based
   // on type, it caches such generated objects, and delegates the actual
   // loading and saving to these generated objects.
   static public ObjectManagerFactory ObjectManagerFactory { get; set; }

   Dictionary<Type, IObjectManager> objectManagers;

   public List<T> Load<T>(Selection selection) 
   {
      IObjectManager m;
      Type t = typeof(T);
      if (!objectManagers.TryGetValue(t, out m))
      {
         m = ObjectManagerFactory.CreateManager(t);
         objectManagers[t] = m;
      }
      return (T)m.Load(selection);
   }

   // Similarly for Save, the implementation in Storage only sees if an ObjectManager
   // for the type already exists, and if not has the factory create one and cache
   // the result, then delegate the actual saving to the ObjectManager instance.
   public void Save(object data) { ... }
}

public class Toto : IFieldAccessible
{
   int n;
   string s;
   Toto parent;

   object[] IFieldAccessible GetFieldValues()
   {
      return new object[] { n, s, parent };
   }

   void IFieldAccessible SetFieldValues(object[] values)
   {
      n = (int)values[0];
      s = (string)values[1];
      parent = (Toto)values[2];
   }

   // .. other members that we don't really care about; only fields matter.
}