Index: branches/New Persistence Exploration/Persistence/Persistence/Core/DataMemberAccessor.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Core/DataMemberAccessor.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Core/DataMemberAccessor.cs	(revision 1419)
@@ -12,6 +12,5 @@
     public readonly Getter Get;
     public readonly Setter Set;
-    public readonly string Name;
-    public readonly Type Type;
+    public readonly string Name;    
     public readonly object DefaultValue;
 
@@ -23,6 +22,5 @@
         FieldInfo fieldInfo = (FieldInfo)memberInfo;
         Get = () => fieldInfo.GetValue(obj);
-        Set = value => fieldInfo.SetValue(obj, value);
-        Type = fieldInfo.FieldType;
+        Set = value => fieldInfo.SetValue(obj, value);        
       } else if (memberInfo.MemberType == MemberTypes.Property) {
         PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
@@ -32,6 +30,5 @@
         }
         Get = () => propertyInfo.GetValue(obj, null);
-        Set = value => propertyInfo.SetValue(obj, value, null);
-        Type = propertyInfo.PropertyType;
+        Set = value => propertyInfo.SetValue(obj, value, null);        
       } else {
         throw new NotSupportedException(
@@ -43,8 +40,7 @@
 
     public DataMemberAccessor(
-        string name, Type type, object defaultValue,
+        string name, object defaultValue,
         Getter getter, Setter setter) {
-      Name = name;
-      Type = type;
+      Name = name;      
       DefaultValue = defaultValue;
       Get = getter;
@@ -53,6 +49,5 @@
 
     public DataMemberAccessor(object o) {
-      Name = null;
-      Type = o.GetType();
+      Name = null;      
       DefaultValue = null;
       Get = () => o;
@@ -60,8 +55,15 @@
     }
 
+    public DataMemberAccessor(object o, string name) {
+      Name = name;      
+      DefaultValue = null;
+      Get = () => o;
+      Set = null;
+    }
+
+
     public override string ToString() {
-      return String.Format("DataMember({0}, {1}, {2}, {3}, {4})",
+      return String.Format("DataMember({0}, {2}, {3}, {4})",
         Name,
-        Type == null ? "<null>" : Type.FullName,
         DefaultValue ?? "<null>",
         Get.Method, Set.Method);
Index: branches/New Persistence Exploration/Persistence/Persistence/Core/DeSerializer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Core/DeSerializer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Core/DeSerializer.cs	(revision 1419)
@@ -3,6 +3,5 @@
 using HeuristicLab.Persistence.Interfaces;
 
-namespace HeuristicLab.Persistence.Core {
-
+namespace HeuristicLab.Persistence.Core {  
 
   struct ParentReference { }
@@ -19,18 +18,19 @@
 
     public object Obj { get; private set; }
-    public readonly List<object> customValues;
+    public List<Tag> customValues;
 
     public CustomComposite(object obj) {
       Obj = obj;
-      customValues = new List<object>();
+      customValues = new List<Tag>();
     }
 
-    public void AddValue(object value) {
-      customValues.Add(value);
+    public void AddValue(string name, object value) {
+      customValues.Add(new Tag(name, value));
     }
 
-    public Setter GetSetter(string name) {
+    public Setter GetSetter(string name) {      
       int index = customValues.Count - 1;
-      return value => customValues[index] = value;
+      Tag t = customValues[index];      
+      return value => t.Value = value;
     }
   }
@@ -122,6 +122,8 @@
       if ( serializerMapping.ContainsKey(type) )
         decomposer = serializerMapping[type] as IDecomposer;      
-      if (decomposer != null) {
-        instance = new ParentReference();
+      if (decomposer != null) {        
+        instance = decomposer.CreateInstance(type);
+        if (instance == null)
+          instance = new ParentReference();
         parentStack.Push(new CustomComposite(instance));        
       } else {        
@@ -143,6 +145,6 @@
       if (decomposer != null) {
         CustomComposite customComposite = (CustomComposite)parentStack.Pop();
-        object deserializedObject =
-          decomposer.Compose(customComposite.customValues, type);
+        object deserializedObject =          
+          decomposer.Populate(customComposite.Obj, customComposite.customValues, type);
         if ( end.Id != null )
           id2obj[(int)end.Id] = deserializedObject;        
@@ -188,5 +190,5 @@
           ((StorableComposite)accessibleObject).SetValue(name, value);
         } else if (accessibleObject is CustomComposite) {
-          ((CustomComposite)accessibleObject).AddValue(value);
+          ((CustomComposite)accessibleObject).AddValue(name, value);
         }
       }
Index: branches/New Persistence Exploration/Persistence/Persistence/Core/Serializer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Core/Serializer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Core/Serializer.cs	(revision 1419)
@@ -67,5 +67,5 @@
     public IEnumerator<ISerializationToken> GetEnumerator() {
       DataMemberAccessor rootAccessor = new DataMemberAccessor(
-        rootName, obj.GetType(), null, () => obj, null);
+        rootName, null, () => obj, null);
       IEnumerator<ISerializationToken> iterator = Serialize(rootAccessor);
       while (iterator.MoveNext())
@@ -110,8 +110,9 @@
 
     private IEnumerator<ISerializationToken> CompositeEnumerator(string name,
-        IEnumerable values, int? id, int typeId) {
+        IEnumerable<Tag> tags, int? id, int typeId) {
       yield return new BeginToken(name, typeId, id);      
-        foreach (object o in values) {
-          IEnumerator<ISerializationToken> iterator = Serialize(new DataMemberAccessor(o));
+        foreach (var tag in tags) {
+          IEnumerator<ISerializationToken> iterator = Serialize(            
+            new DataMemberAccessor(tag.Value, tag.Name));
           while (iterator.MoveNext())
             yield return iterator.Current;
@@ -132,5 +133,5 @@
         }
       }
-      if (nSubComponents == 0 && ! EmptyStorableClassAttribute.IsEmpyStorable(value)) {
+      if (nSubComponents == 0 && ! EmptyStorableClassAttribute.IsEmpyStorable(value.GetType())) {
         throw new ApplicationException(
           String.Format(
Index: branches/New Persistence Exploration/Persistence/Persistence/Core/StorableAttribute.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Core/StorableAttribute.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Core/StorableAttribute.cs	(revision 1419)
@@ -12,9 +12,8 @@
   public class EmptyStorableClassAttribute : Attribute {
     private static readonly Dictionary<Type, bool> emptyTypeInfo = new Dictionary<Type, bool>();
-    public static bool IsEmpyStorable(object o) {
-      Type type = o.GetType();
+    public static bool IsEmpyStorable(Type type) {      
       if (emptyTypeInfo.ContainsKey(type))
         return emptyTypeInfo[type];
-      foreach (var attribute in o.GetType().GetCustomAttributes(false)) {
+      foreach (var attribute in type.GetCustomAttributes(false)) {
         EmptyStorableClassAttribute empty = attribute as EmptyStorableClassAttribute;
         if (empty != null) {
Index: branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/ArrayDecomposer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/ArrayDecomposer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/ArrayDecomposer.cs	(revision 1419)
@@ -3,4 +3,5 @@
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Persistence.Default.Decomposers {
@@ -13,28 +14,32 @@
     }
 
-    public IEnumerable DeCompose(object array) {
+    public IEnumerable<Tag> DeCompose(object array) {
       Array a = (Array)array;
-      yield return a.Rank;
+      yield return new Tag("rank", a.Rank);
       for (int i = 0; i < a.Rank; i++) {
-        yield return a.GetLength(i);
+        yield return new Tag("length_" + i, a.GetLength(i));
       }
       foreach (object o in (Array)array) {
-        yield return o;
+        yield return new Tag(null, o);
       }
     }
 
-    public object Compose(IEnumerable elements, Type t) {
-      IEnumerator e = elements.GetEnumerator();
+    public object CreateInstance(Type t) {
+      return null;
+    }
+
+    public object Populate(object instance, IEnumerable<Tag> elements, Type t) {
+      IEnumerator<Tag> e = elements.GetEnumerator();
       e.MoveNext();
-      int rank = (int)e.Current;
+      int rank = (int)e.Current.Value;
       int[] lengths = new int[rank];
       for (int i = 0; i < rank; i++) {
         e.MoveNext();
-        lengths[i] = (int)e.Current;
+        lengths[i] = (int)e.Current.Value;
       }
       Array a = Array.CreateInstance(t.GetElementType(), lengths);      
       int[] positions = new int[rank];
       while (e.MoveNext()) {
-        a.SetValue(e.Current, positions);
+        a.SetValue(e.Current.Value, positions);
         positions[0] += 1;
         for (int i = 0; i < rank-1; i++) {
Index: branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/DictionaryDecomposer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/DictionaryDecomposer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/DictionaryDecomposer.cs	(revision 1419)
@@ -3,4 +3,5 @@
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Persistence.Default.Decomposers {
@@ -13,19 +14,23 @@
     }
 
-    public IEnumerable DeCompose(object o) {
+    public IEnumerable<Tag> DeCompose(object o) {
       IDictionary dict = (IDictionary)o;      
       foreach ( DictionaryEntry entry in dict) {
-        yield return entry.Key;
-        yield return entry.Value;
+        yield return new Tag("key", entry.Key);
+        yield return new Tag("value", entry.Value);
       }
     }
 
-    public object Compose(IEnumerable o, Type t) {
-      IDictionary dict = (IDictionary)Activator.CreateInstance(t, true);
-      IEnumerator iter = o.GetEnumerator();
+    public object CreateInstance(Type t) {
+      return Activator.CreateInstance(t, true);
+    }
+
+    public object Populate(object instance, IEnumerable<Tag> o, Type t) {
+      IDictionary dict = (IDictionary)instance;
+      IEnumerator<Tag> iter = o.GetEnumerator();
       while (iter.MoveNext()) {
-        object key = iter.Current;
+        object key = iter.Current.Value;
         iter.MoveNext();
-        object value = iter.Current;
+        object value = iter.Current.Value;
         dict.Add(key, value);
       }
Index: branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/EnumerableDecomposer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/EnumerableDecomposer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/EnumerableDecomposer.cs	(revision 1419)
@@ -4,4 +4,5 @@
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Persistence.Default.Decomposers {
@@ -20,15 +21,20 @@
           BindingFlags.Instance,
           null, Type.EmptyTypes, null) != null;        
-    }    
-
-    public IEnumerable DeCompose(object obj) {
-      return (IEnumerable)obj;
     }
 
-    public object Compose(IEnumerable objects, Type type) {
-      object instance = Activator.CreateInstance(type, true);
+    public IEnumerable<Tag> DeCompose(object obj) {
+      foreach (object o in (IEnumerable)obj) {
+        yield return new Tag(null, o);
+      }
+    }
+
+    public object CreateInstance(Type type) {
+      return Activator.CreateInstance(type, true);      
+    }
+
+    public object Populate(object instance, IEnumerable<Tag> objects, Type type) {
       MethodInfo addMethod = type.GetMethod("Add");
-      foreach (object o in objects) {
-        addMethod.Invoke(instance, new[] {o});        
+      foreach (var pair in objects) {
+        addMethod.Invoke(instance, new[] {pair.Value});
       }
       return instance;
Index: branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/KeyValuePairDecomposer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/KeyValuePairDecomposer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/KeyValuePairDecomposer.cs	(revision 1419)
@@ -1,3 +1,4 @@
 ﻿using System;
+using System.Linq;
 using System.Collections;
 using System.Collections.Generic;
@@ -16,13 +17,21 @@
     }
 
-    public IEnumerable DeCompose(object o) {      
+    public IEnumerable<Tag> DeCompose(object o) {      
       Type t = o.GetType();
-      yield return t.GetProperty("Key").GetValue(o, null);
-      yield return t.GetProperty("Value").GetValue(o, null);
+      yield return new Tag("key", t.GetProperty("Key").GetValue(o, null));
+      yield return new Tag("value", t.GetProperty("Value").GetValue(o, null));
     }
 
-    public object Compose(IEnumerable o, Type t) {      
-      return Activator.CreateInstance(t,
-        new List<object>((IEnumerable<object>)o).ToArray());
+    public object CreateInstance(Type type) {
+      return null;
+    }
+
+    public object Populate(object instance, IEnumerable<Tag> o, Type t) {
+      IEnumerator<Tag> iter = o.GetEnumerator();
+      iter.MoveNext();
+      object key = iter.Current.Value;
+      iter.MoveNext();
+      object value = iter.Current.Value;
+      return Activator.CreateInstance(t, new object[] { key, value });      
     }    
   }
Index: branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/TypeDecomposer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/TypeDecomposer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/TypeDecomposer.cs	(revision 1419)
@@ -3,4 +3,5 @@
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Persistence.Default.Decomposers {
@@ -13,12 +14,16 @@
     }
 
-    public IEnumerable DeCompose(object obj) {
+    public IEnumerable<Tag> DeCompose(object obj) {
       Type t = (Type) obj;
-      yield return t.AssemblyQualifiedName;
+      yield return new Tag("AssemblyQualifiedName", t.AssemblyQualifiedName);
     }
 
-    public object Compose(IEnumerable objects, Type type) {
-      foreach ( string typeName in objects ) {
-        return Type.GetType(typeName);
+    public object CreateInstance(Type type) {
+      return null;
+    }
+
+    public object Populate(object instance, IEnumerable<Tag> objects, Type type) {
+      foreach ( var typeName in objects ) {
+        return Type.GetType((string)typeName.Value);
       }
       return null;
Index: branches/New Persistence Exploration/Persistence/Persistence/HeuristicLab.Persistence.csproj
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/HeuristicLab.Persistence.csproj	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/HeuristicLab.Persistence.csproj	(revision 1419)
@@ -61,4 +61,5 @@
     <Compile Include="Default\Decomposers\KeyValuePairDecomposer.cs" />
     <Compile Include="Default\Decomposers\DictionaryDecomposer.cs" />
+    <Compile Include="Default\Decomposers\StorableDecomposer.cs" />
     <Compile Include="Default\Decomposers\TypeDecomposer.cs" />
     <Compile Include="Default\Xml\Compact\IntArray2XmlFormatters.cs" />
Index: branches/New Persistence Exploration/Persistence/Persistence/Interfaces/IDecomposer.cs
===================================================================
--- branches/New Persistence Exploration/Persistence/Persistence/Interfaces/IDecomposer.cs	(revision 1418)
+++ branches/New Persistence Exploration/Persistence/Persistence/Interfaces/IDecomposer.cs	(revision 1419)
@@ -1,12 +1,50 @@
 ﻿using System;
 using System.Collections;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Persistence.Interfaces {
 
-  public interface IDecomposer {
-    bool CanDecompose(Type type);
-    IEnumerable DeCompose(object obj);
-    object Compose(IEnumerable objects, Type type);
+  public struct Tag {
+    public string Name;
+    public object Value;
+    public Tag(string name, object value) {
+      Name = name;
+      Value = value;
+    }
+    public Tag(object value) {
+      Name = null;
+      Value = value;
+    }
   }
 
+  public interface IDecomposer {
+
+    /// <summary>
+    /// Determines for every type whether the decomposer is applicable.
+    /// </summary>    
+    bool CanDecompose(Type type);
+
+    /// <summary>
+    /// Decompose an object into KeyValuePairs, the Key can be null,
+    /// the order in which elements are generated is guaranteed to be
+    /// the same as they are supplied in the Compose method.
+    /// </summary>    
+    IEnumerable<Tag> DeCompose(object obj);
+
+    /// <summary>
+    /// Create an instance of the object if possible. May return null
+    /// in which case the Populate method must create the instance.
+    /// </summary>
+    /// <param name="type"></param>
+    /// <returns></returns>
+    object CreateInstance(Type type);
+
+    /// <summary>
+    /// Compose an object from the KeyValuePairs previously generated
+    /// in DeCompose. The order in which the values are supplied is
+    /// the same as they where generated. Keys might be null.
+    /// </summary>    
+    object Populate(object instance, IEnumerable<Tag> tags, Type type);
+  }  
+
 }
