Index: trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs
===================================================================
--- trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs	(revision 1958)
+++ trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs	(revision 1960)
@@ -1,3 +1,4 @@
 ﻿using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.Reflection;
@@ -42,4 +43,14 @@
       public StorableAttribute Attribute { get; private set; }
       public MemberInfo MemberInfo { get; private set; }
+      public string DisentangledName { get; private set; }
+      public string FullyQualifiedMemberName {
+        get {
+          return new StringBuilder()
+            .Append(MemberInfo.ReflectedType.FullName)
+            .Append('.')
+            .Append(MemberInfo.Name)
+            .ToString();
+        }
+      }
       public StorableMemberInfo(StorableAttribute attribute, MemberInfo memberInfo) {
         this.Attribute = attribute;
@@ -50,4 +61,10 @@
           .Append('[').Append(Attribute).Append(", ")
           .Append(MemberInfo).Append('}').ToString();
+      }
+      public void SetDisentangledName(string name) {
+        DisentangledName = Attribute.Name ?? name;
+      }
+      public Type GetPropertyDeclaringBaseType() {
+        return ((PropertyInfo)MemberInfo).GetGetMethod(true).GetBaseDefinition().DeclaringType;
       }
     }
@@ -91,67 +108,56 @@
         }
       }
-      return storableMembers;
+      return DisentangleNameMapping(storableMembers);
     }
 
-    public static Dictionary<string, DataMemberAccessor> GetStorableAccessors(object obj) {
-      var storableAccessors = new Dictionary<string, DataMemberAccessor>();
-      var nameMapping = createNameMapping(obj.GetType());
-      var finalNameMapping = analyzeNameMapping(nameMapping);
-      foreach (var mapping in finalNameMapping) {
-        storableAccessors.Add(mapping.Value.Attribute.Name ?? mapping.Key,
-          new DataMemberAccessor(
-            mapping.Value.MemberInfo,
-            mapping.Value.Attribute.Name ?? mapping.Key,
-            mapping.Value.Attribute.DefaultValue,
-            obj));
-      }
-      return storableAccessors;
+    public static IEnumerable<DataMemberAccessor> GetStorableAccessors(object obj) {      
+      foreach (var memberInfo in GetStorableMembers(obj.GetType()))
+        yield return new DataMemberAccessor(
+          memberInfo.MemberInfo,
+          memberInfo.DisentangledName,
+          memberInfo.Attribute.DefaultValue,
+          obj);      
     }
 
-    private static Dictionary<string, StorableMemberInfo> analyzeNameMapping(
-        Dictionary<string, List<StorableMemberInfo>> nameMapping) {
-      var finalNameMapping = new Dictionary<string, StorableMemberInfo>();
-      foreach (var attributes in nameMapping) {
-        if (attributes.Value.Count == 1) {
-          finalNameMapping[attributes.Key] = attributes.Value[0];
-        } else if (attributes.Value[0].MemberInfo.MemberType == MemberTypes.Field) {
-          foreach (var attribute in attributes.Value) {
-            StringBuilder sb = new StringBuilder();
-            sb.Append(attribute.MemberInfo.ReflectedType.FullName).Append('.')
-              .Append(attribute.MemberInfo.Name);
-            finalNameMapping[sb.ToString()] = attribute;
+    private static IEnumerable<StorableMemberInfo> DisentangleNameMapping(
+        IEnumerable<StorableMemberInfo> storableMemberInfos) {
+      var nameGrouping = new Dictionary<string, List<StorableMemberInfo>>();
+      foreach (StorableMemberInfo storable in storableMemberInfos) {
+        if (!nameGrouping.ContainsKey(storable.MemberInfo.Name))
+          nameGrouping[storable.MemberInfo.Name] = new List<StorableMemberInfo>();
+        nameGrouping[storable.MemberInfo.Name].Add(storable);
+      }
+      var memberInfos = new List<StorableMemberInfo>();
+      foreach (var storableMemberInfoGroup in nameGrouping.Values) {        
+        if (storableMemberInfoGroup.Count == 1) {
+          storableMemberInfoGroup[0].SetDisentangledName(storableMemberInfoGroup[0].MemberInfo.Name);
+          memberInfos.Add(storableMemberInfoGroup[0]);
+        } else if (storableMemberInfoGroup[0].MemberInfo.MemberType == MemberTypes.Field) {
+          foreach (var storableMemberInfo in storableMemberInfoGroup) {            
+            storableMemberInfo.SetDisentangledName(storableMemberInfo.FullyQualifiedMemberName);
+            memberInfos.Add(storableMemberInfo);
           }
-        } else {
-          var uniqueAccessors = new Dictionary<Type, StorableMemberInfo>();
-          foreach (var attribute in attributes.Value) {
-            uniqueAccessors[((PropertyInfo)attribute.MemberInfo).GetGetMethod(true).GetBaseDefinition().DeclaringType] =
-              attribute;
-          }
-          if (uniqueAccessors.Count == 1) {
-            var it = uniqueAccessors.Values.GetEnumerator();
-            it.MoveNext();
-            finalNameMapping[attributes.Key] = it.Current;
-          } else {
-            foreach (var attribute in uniqueAccessors.Values) {
-              StringBuilder sb = new StringBuilder();
-              sb.Append(attribute.MemberInfo.DeclaringType.FullName).Append('.')
-                .Append(attribute.MemberInfo.Name);
-              finalNameMapping[sb.ToString()] = attribute;
-            }
-          }
+        } else {          
+          memberInfos.AddRange(MergePropertyAccessors(storableMemberInfoGroup));
         }
       }
-      return finalNameMapping;
+      return memberInfos;
     }
-
-    private static Dictionary<string, List<StorableMemberInfo>> createNameMapping(Type type) {
-      var nameMapping = new Dictionary<string, List<StorableMemberInfo>>();
-      foreach (StorableMemberInfo storable in GetStorableMembers(type)) {
-        if (!nameMapping.ContainsKey(storable.MemberInfo.Name))
-          nameMapping[storable.MemberInfo.Name] = new List<StorableMemberInfo>();
-        nameMapping[storable.MemberInfo.Name].Add(storable);
+    
+    private static IEnumerable<StorableMemberInfo> MergePropertyAccessors(List<StorableMemberInfo> members) {
+      var uniqueAccessors = new Dictionary<Type, StorableMemberInfo>();
+      foreach (var member in members)
+        uniqueAccessors[member.GetPropertyDeclaringBaseType()] = member;                  
+      if (uniqueAccessors.Count == 1) {
+        var storableMemberInfo = uniqueAccessors.Values.First();
+        storableMemberInfo.SetDisentangledName(storableMemberInfo.MemberInfo.Name);
+        yield return storableMemberInfo;
+      } else {
+        foreach (var attribute in uniqueAccessors.Values) {
+          attribute.SetDisentangledName(attribute.FullyQualifiedMemberName);
+          yield return attribute;
+        }
       }
-      return nameMapping;
-    }
+    }    
   }
 }
Index: trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs
===================================================================
--- trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs	(revision 1958)
+++ trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs	(revision 1960)
@@ -33,6 +33,6 @@
 
     public IEnumerable<Tag> Decompose(object obj) {
-      foreach (var mapping in StorableAttribute.GetStorableAccessors(obj)) {
-        yield return new Tag(mapping.Key, mapping.Value.Get());
+      foreach (var accessor in StorableAttribute.GetStorableAccessors(obj)) {
+        yield return new Tag(accessor.Name, accessor.Get());
       }
     }
@@ -48,10 +48,9 @@
         memberDict.Add(iter.Current.Name, iter.Current);
       }
-      foreach (var mapping in StorableAttribute.GetStorableAccessors(instance)) {
-        string name = mapping.Key;
-        if (memberDict.ContainsKey(name)) {
-          mapping.Value.Set(memberDict[name].Value);
-        } else if (mapping.Value.DefaultValue != null) {
-          mapping.Value.Set(mapping.Value.DefaultValue);
+      foreach (var accessor in StorableAttribute.GetStorableAccessors(instance)) {        
+        if (memberDict.ContainsKey(accessor.Name)) {
+          accessor.Set(memberDict[accessor.Name].Value);          
+        } else if (accessor.DefaultValue != null) {
+          accessor.Set(accessor.DefaultValue);          
         }
       }
