source: branches/New Persistence Exploration/Persistence/Persistence/CompoundSerializers.cs @ 1319

using System;
using System.Collections;
using System.Reflection;
using System.Collections.Generic;
namespace Persistence {

  public interface ICompoundSerializer {
    bool CanSerialize(Type type);
    IEnumerable Serialize(object o);
    object DeSerialize(IEnumerable o, Type t);
  }

  public class EnumerableSerializer : ICompoundSerializer {
    public bool CanSerialize(Type type) {
      if (type.GetInterface("IEnumerable") == null)
        return false;
      if (type.GetMethod("GetEnumerator", new Type[] { }) == null)
        return false;
      MethodInfo addMethod = type.GetMethod("Add");
      if (addMethod == null)
        return false;
      if (addMethod.GetParameters().Length != 1)
        return false;
      return true;
    }
    public IEnumerable Serialize(object o) {
      return (IEnumerable)o;
    }
    public object DeSerialize(IEnumerable objects, Type t) {
      object instance = Activator.CreateInstance(t);
      foreach (object o in objects) {
        t.GetMethod("Add").Invoke(instance, new object[] { o });
      }
      return instance;
    }
  }

  public class ArraySerializer : ICompoundSerializer {
    public bool CanSerialize(Type type) {
      return type.IsArray || type == typeof(Array);
    }
    public IEnumerable Serialize(object array) {
      Array a = (Array)array;
      yield return a.Rank;
      for (int i = 0; i < a.Rank; i++) {
        yield return a.GetLength(i);
      }
      foreach (object o in (Array)array) {
        yield return o;
      }
    }
    public object DeSerialize(IEnumerable elements, Type t) {
      IEnumerator e = elements.GetEnumerator();
      e.MoveNext();
      int rank = (int)e.Current;
      int[] lengths = new int[rank];
      for (int i = 0; i < rank; i++) {
        e.MoveNext();
        lengths[i] = (int)e.Current;
      }
      Array a = Array.CreateInstance(t.GetElementType(), lengths);      
      int[] positions = new int[rank];
      while (e.MoveNext()) {
        a.SetValue(e.Current, positions);
        positions[0] += 1;
        for (int i = 0; i < rank-1; i++) {
          if (positions[i] >= lengths[i]) {
            positions[i] = 0;
            positions[i + 1] += 1;
          } else {
            break;
          }
        }
      }
      return a;
    }
  }

  public class KeyValuePair2XmlSerializer : ICompoundSerializer {    
    public bool CanSerialize(Type type) {
      return type.IsGenericType &&
        type.GetGenericTypeDefinition().Name == "KeyValuePair`2";
    }
    public IEnumerable Serialize(object o) {      
      Type t = o.GetType();
      yield return t.GetProperty("Key").GetValue(o, null);
      yield return t.GetProperty("Value").GetValue(o, null);
    }
    public object DeSerialize(IEnumerable o, Type t) {
      return Activator.CreateInstance(t,
        new List<object>((IEnumerable<object>)o).ToArray());
    }    
  }

  public class Dictionary2XmlSerializer : ICompoundSerializer {
    public bool CanSerialize(Type type) {
      return type.GetInterface("IDictionary") != null;        
    }
    public IEnumerable Serialize(object o) {
      IDictionary dict = (IDictionary)o;      
      foreach ( DictionaryEntry entry in dict) {
        yield return entry.Key;
        yield return entry.Value;
      }
    }
    public object DeSerialize(IEnumerable o, Type t) {
      IDictionary dict = (IDictionary)Activator.CreateInstance(t);
      IEnumerator iter = o.GetEnumerator();
      while (iter.MoveNext()) {
        object key = iter.Current;
        iter.MoveNext();
        object value = iter.Current;
        dict.Add(key, value);
      }
      return dict;
    }
  }

}