Index: anches/New Persistence Exploration/Persistence/Persistence/CompoundSerializers.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/CompoundSerializers.cs	(revision 1347)
+++ 	(revision )
@@ -1,119 +1,0 @@
-﻿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, true);
-      foreach (object o in objects) {
-        t.GetMethod("Add").Invoke(instance, new[] { 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, true);
-      IEnumerator iter = o.GetEnumerator();
-      while (iter.MoveNext()) {
-        object key = iter.Current;
-        iter.MoveNext();
-        object value = iter.Current;
-        dict.Add(key, value);
-      }
-      return dict;
-    }
-  }
-
-}
Index: /branches/New Persistence Exploration/Persistence/Persistence/DeSerializer.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/DeSerializer.cs	(revision 1347)
+++ /branches/New Persistence Exploration/Persistence/Persistence/DeSerializer.cs	(revision 1348)
@@ -1,5 +1,8 @@
 ﻿using System.Collections.Generic;
 using System;
-namespace Persistence {  
+using System.Reflection;
+using System.Text;
+
+namespace Persistence {
 
   public class DeSerializer {
@@ -62,6 +65,6 @@
     private readonly Stack<IAccessibleObject> compositeStack;
 
-    private readonly Dictionary<Type, IPrimitiveSerializer> primitiveSerializers;
-    private readonly List<ICompoundSerializer> customSerializers;
+    private readonly Dictionary<Type, IFormatter> primitiveSerializers;
+    private readonly List<IDecomposer> customSerializers;
 
     delegate void Thunk();
@@ -69,10 +72,10 @@
 
     public DeSerializer() : this(
-      InterfaceInstantiatior.InstantiateAll<IPrimitiveSerializer>(),
-      InterfaceInstantiatior.InstantiateAll<ICompoundSerializer>()) {}    
+      InterfaceInstantiatior.InstantiateAll<IFormatter>(),
+      InterfaceInstantiatior.InstantiateAll<IDecomposer>()) {}    
 
     public DeSerializer(
-        IEnumerable<IPrimitiveSerializer> primitiveSerializers,
-        IEnumerable<ICompoundSerializer> customSerializers) {
+        IEnumerable<IFormatter> primitiveSerializers,
+        IEnumerable<IDecomposer> customSerializers) {
       id2obj = new Dictionary<int, object>();
       compositeStack = new Stack<IAccessibleObject>();
@@ -84,9 +87,9 @@
                      {typeof (Null), NullHandler}
                    };
-      this.primitiveSerializers = new Dictionary<Type, IPrimitiveSerializer>();
-      foreach (IPrimitiveSerializer ps in primitiveSerializers) {
+      this.primitiveSerializers = new Dictionary<Type, IFormatter>();
+      foreach (IFormatter ps in primitiveSerializers) {
         this.primitiveSerializers.Add(ps.Type, ps);
       }
-      this.customSerializers = new List<ICompoundSerializer>(customSerializers);
+      this.customSerializers = new List<IDecomposer>(customSerializers);
     }
 
@@ -119,9 +122,9 @@
     private void CompositeEndHandler(IParseToken token) {
       CompositeEnd end = (CompositeEnd)token;
-      ICompoundSerializer compoundSerializer = FindCompoundSerializer(end.Type);
-      if (compoundSerializer != null) {
+      IDecomposer decomposer = FindCompoundSerializer(end.Type);
+      if (decomposer != null) {
         CustomObject customObject = (CustomObject)compositeStack.Pop();
         object deserializedObject =
-          compoundSerializer.DeSerialize(customObject.customValues, end.Type);
+          decomposer.DeSerialize(customObject.customValues, end.Type);
         if ( end.Id != null )
           id2obj[(int)end.Id] = deserializedObject;        
@@ -133,6 +136,6 @@
       }
     }
-    private ICompoundSerializer FindCompoundSerializer(Type type) {
-      foreach (ICompoundSerializer serializer in customSerializers) {
+    private IDecomposer FindCompoundSerializer(Type type) {
+      foreach (IDecomposer serializer in customSerializers) {
         if (serializer.CanSerialize(type))
           return serializer;
Index: /branches/New Persistence Exploration/Persistence/Persistence/Decomposers.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/Decomposers.cs	(revision 1348)
+++ /branches/New Persistence Exploration/Persistence/Persistence/Decomposers.cs	(revision 1348)
@@ -0,0 +1,119 @@
+﻿using System;
+using System.Collections;
+using System.Reflection;
+using System.Collections.Generic;
+namespace Persistence {
+  
+  public interface IDecomposer {
+    bool CanSerialize(Type type);
+    IEnumerable Serialize(object o);
+    object DeSerialize(IEnumerable o, Type t);
+  }
+
+  public class EnumerableDecomposer : IDecomposer {
+    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, true);
+      foreach (object o in objects) {
+        t.GetMethod("Add").Invoke(instance, new[] { o });
+      }
+      return instance;
+    }
+  }
+
+  public class ArrayDecomposer : IDecomposer {
+    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 KeyValuePairDecomposer : IDecomposer {    
+    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 DictionaryDecomposer : IDecomposer {
+    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, true);
+      IEnumerator iter = o.GetEnumerator();
+      while (iter.MoveNext()) {
+        object key = iter.Current;
+        iter.MoveNext();
+        object value = iter.Current;
+        dict.Add(key, value);
+      }
+      return dict;
+    }
+  }
+
+}
Index: /branches/New Persistence Exploration/Persistence/Persistence/Persistence.csproj
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/Persistence.csproj	(revision 1347)
+++ /branches/New Persistence Exploration/Persistence/Persistence/Persistence.csproj	(revision 1348)
@@ -56,6 +56,6 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Serializer.cs" />
-    <Compile Include="CompoundSerializers.cs" />
-    <Compile Include="PrimitiveSerializers.cs" />
+    <Compile Include="Decomposers.cs" />
+    <Compile Include="PrimitiveFormatters.cs" />
     <Compile Include="Test\NewSerializationTest.cs" />
     <Compile Include="Tokens.cs" />
Index: /branches/New Persistence Exploration/Persistence/Persistence/PrimitiveFormatters.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/PrimitiveFormatters.cs	(revision 1348)
+++ /branches/New Persistence Exploration/Persistence/Persistence/PrimitiveFormatters.cs	(revision 1348)
@@ -0,0 +1,198 @@
+﻿using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.Globalization;
+namespace Persistence {
+
+  public interface IFormat {
+    string Name { get; }
+  }
+
+  public interface IFormatter {
+    Type Type { get; }
+    IFormat Format { get; }
+    object Serialize(object o);
+    object DeSerialize(object o);
+  }
+
+  public class XmlFormat : IFormat {
+    public string Name { get { return "XML"; } }
+    public static readonly XmlFormat Instance = new XmlFormat();    
+  }
+
+  public class String2XmlFormatter : IFormatter {
+    public Type Type { get { return typeof(string); } }
+    public IFormat Format { get { return XmlFormat.Instance;  } }
+    public object Serialize(object o) {      
+      return "<![CDATA[" +
+        ((string)o).Replace("]]>", "]]]]><![CDATA[>") +
+        "]]>";
+    }
+    public object DeSerialize(object o) {
+      StringBuilder sb = new StringBuilder();
+      foreach (string s in ((string)o).Split(
+        new[] { "<![CDATA[", "]]>" },
+        StringSplitOptions.RemoveEmptyEntries)) {
+        sb.Append(s);
+      }
+      return sb.ToString();
+    }
+  }
+
+  public class Int2XmlFormatter : IFormatter {
+    public Type Type { get { return typeof(int); } }
+    public IFormat Format { get { return XmlFormat.Instance; } }
+    public object Serialize(object o) {
+      return ((int)o).ToString();
+    }
+    public object DeSerialize(object o) {
+      return int.Parse((string)o);
+    }
+  }
+
+  public class Double2XmlFormatter : IFormatter {    
+    public Type Type { get { return typeof(double); } }
+    public IFormat Format { get { return XmlFormat.Instance; } }
+    public object Serialize(object o) {
+      return ((double)o).ToString("r", CultureInfo.InvariantCulture);      
+    }
+    public object DeSerialize(object o) {
+      return double.Parse((string)o, CultureInfo.InvariantCulture);
+    }
+  }
+
+  public class Boolean2XmlFormatter : IFormatter {    
+    public Type Type { get { return typeof(bool); } }
+    public IFormat Format { get { return XmlFormat.Instance; } }
+    public object Serialize(object o) {
+      return ((bool)o).ToString();
+    }
+    public object DeSerialize(object o) {
+      return bool.Parse((string)o);
+    }
+  }
+
+  public class DateTime2XmlFormatter : IFormatter {    
+    public Type Type { get { return typeof(DateTime); } }
+    public IFormat Format { get { return XmlFormat.Instance; } }  
+    public object Serialize(object o) {
+      return ((DateTime)o).Ticks.ToString();      
+    }
+    public object DeSerialize(object o) {
+      return new DateTime(long.Parse((string)o));
+    }
+  }
+
+  public abstract class NumberArray2XmlFormatter : IFormatter {
+    public abstract Type Type { get; }
+    public IFormat Format { get { return XmlFormat.Instance; } }
+    protected virtual string Separator { get { return ";"; } }
+    protected abstract string formatValue(object o);
+    protected abstract object parseValue(string o);
+    public object Serialize(object obj) {      
+      Array a = (Array)obj;
+      StringBuilder sb = new StringBuilder();
+      sb.Append(a.Rank);      
+      for (int i = 0; i < a.Rank; i++) {
+        sb.Append(Separator);
+        sb.Append(a.GetLength(i));
+      }
+      foreach (object o in a) {
+        sb.Append(Separator);
+        sb.Append(formatValue(o));
+      }
+      return sb.ToString();
+    }
+    public object DeSerialize(object o) {
+      IEnumerator values =
+        ((string) o)
+        .Split(new[] {Separator},
+        StringSplitOptions.RemoveEmptyEntries).GetEnumerator();
+      values.MoveNext();
+      int rank = int.Parse((string)values.Current);
+      int[] lengths = new int[rank];
+      for ( int i = 0; i<rank; i++ ) {
+        values.MoveNext();
+        lengths[i] = int.Parse((string)values.Current);
+      }
+      Array a = Array.CreateInstance(this.Type.GetElementType(), lengths);
+      int[] positions = new int[rank];
+      while ( values.MoveNext() ) {
+        a.SetValue(parseValue((string)values.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 IntArray2XmlFormatter : NumberArray2XmlFormatter {
+    public override Type Type { get { return typeof(int[]); } }
+    protected override string formatValue(object o) { return o.ToString(); }
+    protected override object parseValue(string o) { return int.Parse(o); }
+  }
+  public class Int2DArray2XmlFormatter : IntArray2XmlFormatter {
+    public override Type Type { get { return typeof (int[,]); } }
+  }
+  public class Int3DArray2XmlFormatter : IntArray2XmlFormatter {
+    public override Type Type { get { return typeof(int[,,]); } }
+  }
+  public class DoubleArray2XmlFormatter : NumberArray2XmlFormatter {
+    public override Type Type { get { return typeof(double[]); } }
+    protected override string formatValue(object o) { return ((double) o).ToString("r"); }
+    protected override object parseValue(string o) { return double.Parse(o); }    
+  }
+  public class Double2DArray2XmlFormatter : DoubleArray2XmlFormatter {
+    public override Type Type { get { return typeof(double[,]); } }    
+  }
+  public class Double3DArray2XmlFormatter : DoubleArray2XmlFormatter {
+    public override Type Type { get { return typeof(double[,,]); } }
+  }
+
+  public abstract class NumberEnumeration2XmlFormatter : IFormatter {
+    public abstract Type Type { get; }
+    public IFormat Format { get { return XmlFormat.Instance; } }
+    protected virtual string Separator { get { return ";"; } }
+    protected abstract void Add(IEnumerable enumeration, object o);
+    protected abstract object Instantiate();
+    protected abstract string formatValue(object o);
+    protected abstract object parseValue(string o);    
+    public object Serialize(object o) {
+      StringBuilder sb = new StringBuilder();
+      foreach (var value in (IEnumerable) o) {        
+        sb.Append(formatValue(value));
+        sb.Append(Separator);
+      }
+      return sb.ToString();
+    }  
+    public object DeSerialize(object o) {
+      IEnumerable enumeration = (IEnumerable) Instantiate();        
+      string[] values = ((string) o).Split(new[] {Separator}, StringSplitOptions.RemoveEmptyEntries);
+      foreach ( var value in values ) {
+        Add(enumeration, parseValue(value));
+      }
+      return enumeration;
+    }
+  }
+  public class IntList2XmlFormatter : NumberEnumeration2XmlFormatter {
+    public override Type Type { get { return typeof(List<int>); } }
+    protected override void Add(IEnumerable enumeration, object o) { ((List<int>)enumeration).Add((int)o); }
+    protected override object Instantiate() { return new List<int>(); }
+    protected override string formatValue(object o) { return o.ToString(); }
+    protected override object parseValue(string o) { return int.Parse(o); }
+  }  
+  public class DoubleList2XmlFormatter : NumberEnumeration2XmlFormatter {
+    public override Type Type { get { return typeof(List<double>); } }
+    protected override void Add(IEnumerable enumeration, object o) { ((List<double>)enumeration).Add((int)o); }
+    protected override object Instantiate() { return new List<double>(); }
+    protected override string formatValue(object o) { return ((double) o).ToString("r"); }
+    protected override object parseValue(string o) { return double.Parse(o); }
+  }
+}
Index: anches/New Persistence Exploration/Persistence/Persistence/PrimitiveSerializers.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/PrimitiveSerializers.cs	(revision 1347)
+++ 	(revision )
@@ -1,174 +1,0 @@
-﻿using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Text;
-using System.Globalization;
-namespace Persistence {
-
-  public interface IPrimitiveSerializer {
-    Type Type { get; }
-    object Serialize(object o);
-    object DeSerialize(object o);
-  }
-
-  public class String2XMLSerializer : IPrimitiveSerializer {
-    public Type Type { get { return typeof(string); } }
-    public object Serialize(object o) {
-      return "<![CDATA[" +
-        ((string)o).Replace("]]>", "]]]]><![CDATA[>") +
-        "]]>";
-    }
-    public object DeSerialize(object o) {
-      StringBuilder sb = new StringBuilder();
-      foreach (string s in ((string)o).Split(
-        new[] { "<![CDATA[", "]]>" },
-        StringSplitOptions.RemoveEmptyEntries)) {
-        sb.Append(s);
-      }
-      return sb.ToString();
-    }
-  }
-
-  public class Int2XMLSerializer : IPrimitiveSerializer {
-    public Type Type { get { return typeof(int); } }
-    public object Serialize(object o) {
-      return ((int)o).ToString();
-    }
-    public object DeSerialize(object o) {
-      return int.Parse((string)o);
-    }
-  }
-
-  public class Double2XmlSerializer : IPrimitiveSerializer {    
-    public Type Type { get { return typeof(double); } }        
-    public object Serialize(object o) {
-      return ((double)o).ToString("r", CultureInfo.InvariantCulture);      
-    }
-    public object DeSerialize(object o) {
-      return double.Parse((string)o, CultureInfo.InvariantCulture);
-    }
-  }
-
-  public class Boolean2XmlSerializer : IPrimitiveSerializer {    
-    public Type Type { get { return typeof(bool); } }    
-    public object Serialize(object o) {
-      return ((bool)o).ToString();
-    }
-    public object DeSerialize(object o) {
-      return bool.Parse((string)o);
-    }
-  }
-
-  public class DateTime2XmlSerializer : IPrimitiveSerializer {    
-    public Type Type { get { return typeof(DateTime); } }      
-    public object Serialize(object o) {
-      return ((DateTime)o).Ticks.ToString();      
-    }
-    public object DeSerialize(object o) {
-      return new DateTime(long.Parse((string)o));
-    }
-  }
-
-  public abstract class NumberArray2XmlSerializer : IPrimitiveSerializer {
-    public abstract Type Type { get; }    
-    protected virtual string Separator { get { return ";"; } }
-    protected abstract string formatValue(object o);
-    protected abstract object parseValue(string o);
-    public object Serialize(object obj) {      
-      Array a = (Array)obj;
-      StringBuilder sb = new StringBuilder();
-      sb.Append(a.Rank);      
-      for (int i = 0; i < a.Rank; i++) {
-        sb.Append(Separator);
-        sb.Append(a.GetLength(i));
-      }
-      foreach (object o in a) {
-        sb.Append(Separator);
-        sb.Append(formatValue(o));
-      }
-      return sb.ToString();
-    }
-    public object DeSerialize(object o) {
-      IEnumerator values =
-        ((string) o)
-        .Split(new[] {Separator},
-        StringSplitOptions.RemoveEmptyEntries).GetEnumerator();
-      values.MoveNext();
-      int rank = int.Parse((string)values.Current);
-      int[] lengths = new int[rank];
-      for ( int i = 0; i<rank; i++ ) {
-        values.MoveNext();
-        lengths[i] = int.Parse((string)values.Current);
-      }
-      Array a = Array.CreateInstance(this.Type.GetElementType(), lengths);
-      int[] positions = new int[rank];
-      while ( values.MoveNext() ) {
-        a.SetValue(parseValue((string)values.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 IntArray2XmlSerializer : NumberArray2XmlSerializer {
-    public override Type Type { get { return typeof(int[]); } }
-    protected override string formatValue(object o) { return o.ToString(); }
-    protected override object parseValue(string o) { return int.Parse(o); }
-  }
-  public class Int2DArray2XmlSerializer : IntArray2XmlSerializer {
-    public override Type Type { get { return typeof (int[,]); } }
-  }
-  public class Int3DArray2XmlSerializer : IntArray2XmlSerializer {
-    public override Type Type { get { return typeof(int[,,]); } }
-  }
-  public class DoubleArray2XmlSerializer : NumberArray2XmlSerializer {
-    public override Type Type { get { return typeof(double[]); } }
-    protected override string formatValue(object o) { return ((double) o).ToString("r"); }
-    protected override object parseValue(string o) { return double.Parse(o); }    
-  }
-  public class Double2DArray2XmlSerializer : DoubleArray2XmlSerializer {
-    public override Type Type { get { return typeof(double[,]); } }    
-  }
-  public class Double3DArray2XmlSerializer : DoubleArray2XmlSerializer {
-    public override Type Type { get { return typeof(double[,,]); } }
-  }
-
-  public abstract class NumberEnumeration2XmlSerializer : IPrimitiveSerializer {
-    public abstract Type Type { get; }
-    protected virtual string Separator { get { return ";"; } }
-    protected abstract void Add(IEnumerable enumeration, object o);
-    protected abstract object Instantiate();
-    protected abstract string formatValue(object o);
-    protected abstract object parseValue(string o);    
-    public object Serialize(object o) {
-      StringBuilder sb = new StringBuilder();
-      foreach (var value in (IEnumerable) o) {        
-        sb.Append(formatValue(value));
-        sb.Append(Separator);
-      }
-      return sb.ToString();
-    }  
-    public object DeSerialize(object o) {
-      IEnumerable enumeration = (IEnumerable) Instantiate();        
-      string[] values = ((string) o).Split(new[] {Separator}, StringSplitOptions.RemoveEmptyEntries);
-      foreach ( var value in values ) {
-        Add(enumeration, parseValue(value));
-      }
-      return enumeration;
-    }
-  }
-  public class IntList2XmlSerializer : NumberEnumeration2XmlSerializer {
-    public override Type Type { get { return typeof(List<int>); } }
-    protected override void Add(IEnumerable enumeration, object o) { ((List<int>)enumeration).Add((int)o); }
-    protected override object Instantiate() { return new List<int>(); }
-    protected override string formatValue(object o) { return o.ToString(); }
-    protected override object parseValue(string o) { return int.Parse(o); }
-  }  
-}
Index: /branches/New Persistence Exploration/Persistence/Persistence/Serializer.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/Serializer.cs	(revision 1347)
+++ /branches/New Persistence Exploration/Persistence/Persistence/Serializer.cs	(revision 1348)
@@ -10,28 +10,28 @@
     private readonly string rootName;
     private readonly Dictionary<object, int> obj2id;
-    private readonly Dictionary<Type, IPrimitiveSerializer> primitiveSerializers;
-    private readonly List<ICompoundSerializer> compoundSerializers;
+    private readonly Dictionary<Type, IFormatter> primitiveSerializers;
+    private readonly List<IDecomposer> compoundSerializers;
     private readonly Dictionary<Type, int> typeCache;
 
     public Serializer(object obj) :
       this(obj,
-      InterfaceInstantiatior.InstantiateAll<IPrimitiveSerializer>(),
-      InterfaceInstantiatior.InstantiateAll<ICompoundSerializer>()) {}
+      InterfaceInstantiatior.InstantiateAll<IFormatter>(),
+      InterfaceInstantiatior.InstantiateAll<IDecomposer>()) {}
 
     public Serializer(object obj,
-        IEnumerable<IPrimitiveSerializer> primitiveSerializers,
-        IEnumerable<ICompoundSerializer> compoundSerializers) :
+        IEnumerable<IFormatter> primitiveSerializers,
+        IEnumerable<IDecomposer> compoundSerializers) :
       this(obj, primitiveSerializers, compoundSerializers, "ROOT") { }
 
     public Serializer(object obj,
-        IEnumerable<IPrimitiveSerializer> primitiveSerializers,
-        IEnumerable<ICompoundSerializer> compoundSerializers, string rootName) {
+        IEnumerable<IFormatter> primitiveSerializers,
+        IEnumerable<IDecomposer> compoundSerializers, string rootName) {
       this.obj = obj;
       this.rootName = rootName;
-      this.primitiveSerializers = new Dictionary<Type, IPrimitiveSerializer>();
-      foreach (IPrimitiveSerializer serializer in primitiveSerializers) {
+      this.primitiveSerializers = new Dictionary<Type, IFormatter>();
+      foreach (IFormatter serializer in primitiveSerializers) {
         this.primitiveSerializers.Add(serializer.Type, serializer);
       }
-      this.compoundSerializers = new List<ICompoundSerializer>(compoundSerializers);
+      this.compoundSerializers = new List<IDecomposer>(compoundSerializers);
       obj2id = new Dictionary<object, int> {{new object(), 0}};
       typeCache = new Dictionary<Type, int>();
@@ -48,7 +48,10 @@
       while (iterator.MoveNext())
         yield return iterator.Current;
-      Console.WriteLine("TypeCache:f");
-      foreach ( var pair in typeCache )
-        Console.WriteLine(pair.Key);
+      Console.WriteLine("TypeCache:");
+      foreach (var pair in typeCache) {                
+        Console.WriteLine("<TYPE id=\"{0}\" AssemblyQualifiedName=\"{1}\">",
+          pair.Value,
+          pair.Key.AssemblyQualifiedName);
+      }
     }
 
@@ -86,8 +89,8 @@
       
       yield return new BeginToken(accessor, id);
-      ICompoundSerializer customSerializer = FindCompoundSerializer(value.GetType());
+      IDecomposer custom = FindCompoundSerializer(value.GetType());
 
-      if (customSerializer != null) {
-        foreach (object o in customSerializer.Serialize(value)) {
+      if (custom != null) {
+        foreach (object o in custom.Serialize(value)) {
           IEnumerator<ISerializationToken> iterator = Serialize(new DataMemberAccessor(o));
           while (iterator.MoveNext())
@@ -115,6 +118,6 @@
     }
 
-    private ICompoundSerializer FindCompoundSerializer(Type type) {
-      foreach (ICompoundSerializer s in compoundSerializers) {
+    private IDecomposer FindCompoundSerializer(Type type) {
+      foreach (IDecomposer s in compoundSerializers) {
         if (s.CanSerialize(type))
           return s;
Index: /branches/New Persistence Exploration/Persistence/Persistence/StorableAttribute.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Persistence/StorableAttribute.cs	(revision 1347)
+++ /branches/New Persistence Exploration/Persistence/Persistence/StorableAttribute.cs	(revision 1348)
@@ -59,12 +59,12 @@
     }
 
-    private readonly List<ICompoundSerializer> compoundSerializers;
-
-    public CloningFactory(IEnumerable<ICompoundSerializer> compoundSerializers) {
-      this.compoundSerializers = new List<ICompoundSerializer>(compoundSerializers);
+    private readonly List<IDecomposer> compoundSerializers;
+
+    public CloningFactory(IEnumerable<IDecomposer> compoundSerializers) {
+      this.compoundSerializers = new List<IDecomposer>(compoundSerializers);
     }
 
     public CloningFactory() :
-      this(InterfaceInstantiatior.InstantiateAll<ICompoundSerializer>()) { }
+      this(InterfaceInstantiatior.InstantiateAll<IDecomposer>()) { }
 
     delegate object CloneMethod(object obj, Dictionary<object, object> twins);
@@ -106,5 +106,5 @@
       if (type.GetConstructor(new[] { type }) != null)
         return CopyConstructorCloneMethod.Create(type);
-      foreach (ICompoundSerializer serializer in compoundSerializers)
+      foreach (IDecomposer serializer in compoundSerializers)
         if (serializer.CanSerialize(type))
           return CompoundSerializerCloneMethod.Create(serializer, type, this);
@@ -128,12 +128,12 @@
 
     class CompoundSerializerCloneMethod {
-      public static CloneMethod Create(ICompoundSerializer serializer,
+      public static CloneMethod Create(IDecomposer serializer,
           Type type, CloningFactory factory) {
         return new CompoundSerializerCloneMethod(serializer, type, factory).method;
       }
-      private readonly ICompoundSerializer serializer;
+      private readonly IDecomposer serializer;
       private readonly Type type;
       private readonly CloningFactory factory;
-      public CompoundSerializerCloneMethod(ICompoundSerializer serializer,
+      public CompoundSerializerCloneMethod(IDecomposer serializer,
           Type type, CloningFactory factory) {
         this.serializer = serializer;
Index: /branches/New Persistence Exploration/Persistence/Test/NewSerializationTest.cs
===================================================================
--- /branches/New Persistence Exploration/Persistence/Test/NewSerializationTest.cs	(revision 1347)
+++ /branches/New Persistence Exploration/Persistence/Test/NewSerializationTest.cs	(revision 1348)
@@ -120,12 +120,5 @@
     }
 
-    public static void Main() {
-      int[] i = {1, 2, 3};
-      object o = i;
-      Type type = o.GetType().BaseType.BaseType;
-      foreach (MemberInfo mi in type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic )) {
-        if ( mi.MemberType == MemberTypes.Field || mi.MemberType == MemberTypes.Property )
-          Console.WriteLine(mi.Name);
-      }
+    public static void Main() {      
       Test1();
       //Test2();
Index: /branches/New Persistence Exploration/Persistence/Test/Test.csproj
===================================================================
--- /branches/New Persistence Exploration/Persistence/Test/Test.csproj	(revision 1347)
+++ /branches/New Persistence Exploration/Persistence/Test/Test.csproj	(revision 1348)
@@ -49,3 +49,9 @@
     <Compile Include="NewSerializationTest.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
 </Project>
