Index: trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/DataMemberAccessor.cs
===================================================================
--- trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/DataMemberAccessor.cs	(revision 1920)
+++ trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/DataMemberAccessor.cs	(revision 1938)
@@ -12,8 +12,7 @@
     public readonly object DefaultValue;
 
-    public DataMemberAccessor(
-        MemberInfo memberInfo,
-        StorableAttribute storableAttribute,
-        object obj) {
+    public DataMemberAccessor(MemberInfo memberInfo, string name, object defaultvalue, object obj) {
+      Name = name;
+      DefaultValue = defaultvalue;
       if (memberInfo.MemberType == MemberTypes.Field) {
         FieldInfo fieldInfo = (FieldInfo)memberInfo;
@@ -32,10 +31,7 @@
           "The Storable attribute can only be applied to fields and properties.");
       }
-      Name = storableAttribute.Name ?? memberInfo.Name;
-      DefaultValue = storableAttribute.DefaultValue;
     }
 
-    public DataMemberAccessor(
-        string name, object defaultValue,
+    public DataMemberAccessor(string name, object defaultValue,
         Func<object> getter, Action<object> setter) {
       Name = name;
@@ -61,5 +57,5 @@
 
     public override string ToString() {
-      return String.Format("DataMember({0}, {1}, {2}, {3})",
+      return String.Format("DataMemberAccessor({0}, {1}, {2}, {3})",
         Name,
         DefaultValue ?? "<null>",
Index: trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs
===================================================================
--- trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs	(revision 1920)
+++ trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs	(revision 1938)
@@ -2,4 +2,5 @@
 using System.Collections.Generic;
 using System.Reflection;
+using System.Text;
 
 namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {
@@ -14,4 +15,22 @@
     public object DefaultValue { get; set; }
 
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[Storable");
+      if (Name != null || DefaultValue != null)
+        sb.Append('(');
+      if (Name != null) {
+        sb.Append("Name = \"").Append(Name).Append("\"");
+        if (DefaultValue != null)
+          sb.Append(", ");
+      }
+      if (DefaultValue != null)
+        sb.Append("DefaultValue = \"").Append(DefaultValue).Append("\"");
+      if (Name != null || DefaultValue != null)
+        sb.Append(')');
+      sb.Append(']');
+      return sb.ToString();
+    }
+
     private const BindingFlags instanceMembers =
       BindingFlags.Instance |
@@ -20,33 +39,53 @@
       BindingFlags.DeclaredOnly;
 
-    private static Dictionary<KeyValuePair<Type, bool>, IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>> memberCache =
-      new Dictionary<KeyValuePair<Type, bool>, IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>>();
+    public sealed class StorableMemberInfo {
+      public StorableAttribute Attribute { get; private set; }
+      public MemberInfo MemberInfo { get; private set; }
+      public StorableMemberInfo(StorableAttribute attribute, MemberInfo memberInfo) {
+        this.Attribute = attribute;
+        this.MemberInfo = memberInfo;
+      }
+      public override string ToString() {
+        return new StringBuilder()
+          .Append('[').Append(Attribute).Append(", ")
+          .Append(MemberInfo).Append('}').ToString();
+      }
+    }
 
-    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>> GetStorableMembers(Type type) {
+    sealed class TypeQuery {
+      public Type Type { get; private set; }
+      public bool Inherited { get; private set; }
+      public TypeQuery(Type type, bool inherited) {
+        this.Type = type;
+        this.Inherited = inherited;
+      }
+    }
+
+    sealed class MemberCache : Dictionary<TypeQuery, IEnumerable<StorableMemberInfo>> { }
+
+    private static MemberCache memberCache = new MemberCache();
+
+    public static IEnumerable<StorableMemberInfo> GetStorableMembers(Type type) {
       return GetStorableMembers(type, true);
     }
 
-    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>
-        GetStorableMembers(Type type, bool inherited) {
-      var query = new KeyValuePair<Type, bool>(type, inherited);
+    public static IEnumerable<StorableMemberInfo> GetStorableMembers(Type type, bool inherited) {
+      var query = new TypeQuery(type, inherited);
       if (memberCache.ContainsKey(query))
         return memberCache[query];
-      IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>> storablesMembers = GenerateStorableMembers(type, inherited);
+      var storablesMembers = GenerateStorableMembers(type, inherited);
       memberCache[query] = storablesMembers;
       return storablesMembers;
     }
 
-    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>
-        GenerateStorableMembers(Type type, bool inherited) {
-      List<KeyValuePair<StorableAttribute, MemberInfo>> storableMembers =
-        new List<KeyValuePair<StorableAttribute, MemberInfo>>();
+    private static IEnumerable<StorableMemberInfo> GenerateStorableMembers(Type type, bool inherited) {
+      var storableMembers = new List<StorableMemberInfo>();
       if (inherited && type.BaseType != null)
-        storableMembers.AddRange(GenerateStorableMembers(type.BaseType, true));        
+        storableMembers.AddRange(GenerateStorableMembers(type.BaseType, true));
       foreach (MemberInfo memberInfo in type.GetMembers(instanceMembers)) {
         foreach (object attribute in memberInfo.GetCustomAttributes(false)) {
-          StorableAttribute storableAttribute =
-            attribute as StorableAttribute;
+          StorableAttribute storableAttribute = attribute as StorableAttribute;
           if (storableAttribute != null) {
-            storableMembers.Add(new KeyValuePair<StorableAttribute, MemberInfo>(storableAttribute, memberInfo));
+            storableMembers.Add(new StorableMemberInfo(storableAttribute, memberInfo));
           }
         }
@@ -56,12 +95,63 @@
 
     public static Dictionary<string, DataMemberAccessor> GetStorableAccessors(object obj) {
-      Dictionary<string, DataMemberAccessor> storableAccessors =
-        new Dictionary<string, DataMemberAccessor>();
-      foreach (KeyValuePair<StorableAttribute, MemberInfo> pair in GetStorableMembers(obj.GetType())) {
-        storableAccessors.Add(pair.Value.Name,
-          new DataMemberAccessor(pair.Value, pair.Key, 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;
     }
+
+    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;
+          }
+        } 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;
+            }
+          }
+        }
+      }
+      return finalNameMapping;
+    }
+
+    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);
+      }
+      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 1920)
+++ trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs	(revision 1938)
@@ -34,5 +34,5 @@
     public IEnumerable<Tag> Decompose(object obj) {
       foreach (var mapping in StorableAttribute.GetStorableAccessors(obj)) {
-        yield return new Tag(mapping.Value.Name ?? mapping.Key, mapping.Value.Get());
+        yield return new Tag(mapping.Key, mapping.Value.Get());
       }
     }
@@ -49,5 +49,5 @@
       }
       foreach (var mapping in StorableAttribute.GetStorableAccessors(instance)) {
-        string name = mapping.Value.Name ?? mapping.Key;
+        string name = mapping.Key;
         if (memberDict.ContainsKey(name)) {
           mapping.Value.Set(memberDict[name].Value);
