Index: /trunk/sources/HeuristicLab.Persistence/3.3/Core/ConfigurationService.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Core/ConfigurationService.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Core/ConfigurationService.cs	(revision 1625)
@@ -148,7 +148,14 @@
     public Configuration GetDefaultConfig(IFormat format) {
       Dictionary<Type, IFormatter> formatterConfig = new Dictionary<Type, IFormatter>();
-      foreach (IFormatter f in Formatters[format.SerialDataType]) {
-        if (!formatterConfig.ContainsKey(f.SourceType))
-          formatterConfig.Add(f.SourceType, f);
+      if (Formatters.ContainsKey(format.SerialDataType)) {
+        foreach (IFormatter f in Formatters[format.SerialDataType]) {
+          if (!formatterConfig.ContainsKey(f.SourceType))
+            formatterConfig.Add(f.SourceType, f);
+        }
+      } else {
+        Logger.Warn(String.Format(
+          "No formatters found for format {0} with serial data type {1}",
+          format.GetType().VersionInvariantName(),
+          format.SerialDataType.VersionInvariantName()));
       }
       return new Configuration(format, formatterConfig, Decomposers);
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs	(revision 1625)
@@ -34,5 +34,5 @@
       public void CreateInstance() {
         if (Obj != null)
-          throw new ApplicationException("object already instantiated");
+          throw new PersistenceException("object already instantiated");
         Obj = decomposer.CreateInstance(type, metaInfo);
       }
@@ -65,12 +65,18 @@
 
     private Dictionary<Type, object> CreateSerializers(IEnumerable<TypeMapping> typeCache) {
-      var map = new Dictionary<Type, object>();
-      foreach (var typeMapping in typeCache) {
-        Type type = Type.GetType(typeMapping.TypeName, true);
-        typeIds.Add(typeMapping.Id, type);
-        Type serializerType = Type.GetType(typeMapping.Serializer, true);
-        map.Add(type, Activator.CreateInstance(serializerType, true));
-      }
-      return map;
+      try {
+        var map = new Dictionary<Type, object>();
+        foreach (var typeMapping in typeCache) {
+          Type type = Type.GetType(typeMapping.TypeName, true);
+          typeIds.Add(typeMapping.Id, type);
+          Type serializerType = Type.GetType(typeMapping.Serializer, true);
+          map.Add(type, Activator.CreateInstance(serializerType, true));
+        }
+        return map;
+      } catch (Exception e) {
+        throw new PersistenceException(
+          "The serialization type cache could not be loaded.\r\n" +
+          "This usualy happens when you are missing an Assembly/Plugin.", e);
+      }      
     }
 
@@ -93,5 +99,5 @@
           MetaInfoEnd((MetaInfoEndToken)token);
         } else {
-          throw new ApplicationException("invalid token type");
+          throw new PersistenceException("invalid token type");
         }
       }
@@ -105,5 +111,5 @@
         decomposer = serializerMapping[type] as IDecomposer;
       if (decomposer == null)
-        throw new ApplicationException(String.Format(
+        throw new PersistenceException(String.Format(
           "No suitable method for deserialization of type \"{0}\" found.",
           type.VersionInvariantName()));
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Core/FormatterBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Core/FormatterBase.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Core/FormatterBase.cs	(revision 1625)
@@ -1,3 +1,4 @@
 ﻿using System;
+using System.Text;
 
 namespace HeuristicLab.Persistence.Interfaces {
@@ -21,4 +22,14 @@
     }
 
+    public override string ToString() {
+      return new StringBuilder()
+        .Append(this.GetType().Name)
+        .Append('(')
+        .Append(SourceType.Name)
+        .Append("->")
+        .Append(SerialDataType.Name)
+        .ToString();
+    }
+
   }
 
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Core/PersistenceException.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Core/PersistenceException.cs	(revision 1625)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Core/PersistenceException.cs	(revision 1625)
@@ -0,0 +1,14 @@
+﻿using System.Collections.Generic;
+using System;
+using HeuristicLab.Persistence.Interfaces;
+using HeuristicLab.Persistence.Core.Tokens;
+
+namespace HeuristicLab.Persistence.Core {
+
+  public class PersistenceException : Exception {
+    public PersistenceException() : base() { }
+    public PersistenceException(string message) : base(message) { }
+    public PersistenceException(string message, Exception innerException) :  base(message, innerException) { }
+  }
+  
+}
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Core/Serializer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Core/Serializer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Core/Serializer.cs	(revision 1625)
@@ -4,4 +4,5 @@
 using HeuristicLab.Persistence.Interfaces;
 using HeuristicLab.Persistence.Core.Tokens;
+using HeuristicLab.Persistence.Default.Decomposers.Storable;
 
 namespace HeuristicLab.Persistence.Core {
@@ -73,5 +74,5 @@
       if (decomposer != null)
         return CompositeEnumerator(accessor.Name, decomposer.Decompose(value), id, typeId, decomposer.CreateMetaInfo(value));
-      throw new ApplicationException(
+      throw new PersistenceException(
           String.Format(
           "No suitable method for serializing values of type \"{0}\" found.",
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/ArrayDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/ArrayDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/ArrayDecomposer.cs	(revision 1625)
@@ -54,19 +54,25 @@
     }
 
-    public object CreateInstance(Type t, IEnumerable<Tag> metaInfo) {
-      IEnumerator<Tag> e = metaInfo.GetEnumerator();
-      e.MoveNext();
-      int rank = (int)e.Current.Value;
-      int[] lengths = new int[rank];
-      for (int i = 0; i < rank; i++) {
+    public object CreateInstance(Type t, IEnumerable<Tag> metaInfo) {      
+      try {
+        IEnumerator<Tag> e = metaInfo.GetEnumerator();
         e.MoveNext();
-        lengths[i] = (int)e.Current.Value;
-      }
-      int[] lowerBounds = new int[rank];
-      for (int i = 0; i < rank; i++) {
-        e.MoveNext();
-        lowerBounds[i] = (int)e.Current.Value;
-      }
-      return Array.CreateInstance(t.GetElementType(), lengths, lowerBounds);
+        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.Value;
+        }
+        int[] lowerBounds = new int[rank];
+        for (int i = 0; i < rank; i++) {
+          e.MoveNext();
+          lowerBounds[i] = (int)e.Current.Value;
+        }
+        return Array.CreateInstance(t.GetElementType(), lengths, lowerBounds);
+      } catch (InvalidOperationException x) {
+        throw new PersistenceException("Insufficient meta information to construct array instance.", x);
+      } catch (InvalidCastException x) {
+        throw new PersistenceException("Invalid format of array metainfo.", x);
+      }      
     }
 
@@ -83,16 +89,24 @@
       int[] positions = (int[])lowerBounds.Clone();
       IEnumerator<Tag> e = elements.GetEnumerator();
-      while (e.MoveNext()) {
-        int[] currentPositions = positions;
-        a.SetValue(e.Current.Value, currentPositions);
-        positions[0] += 1;
-        for (int i = 0; i < a.Rank - 1; i++) {
-          if (positions[i] >= lengths[i] + lowerBounds[i]) {
-            positions[i] = lowerBounds[i];
-            positions[i + 1] += 1;
-          } else {
-            break;
+      try {
+        while (e.MoveNext()) {
+          int[] currentPositions = positions;
+          a.SetValue(e.Current.Value, currentPositions);
+          positions[0] += 1;
+          for (int i = 0; i < a.Rank - 1; i++) {
+            if (positions[i] >= lengths[i] + lowerBounds[i]) {
+              positions[i] = lowerBounds[i];
+              positions[i + 1] += 1;
+            } else {
+              break;
+            }
           }
         }
+      } catch (InvalidOperationException x) {
+        throw new PersistenceException("Insufficient data to fill array instance", x);
+      } catch (InvalidCastException x) {
+        throw new PersistenceException("Invalid element data. Cannot fill array", x);
+      } catch (IndexOutOfRangeException x) {
+        throw new PersistenceException("Too many elements during array deserialization", x);
       }
     }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/CompactNumberArray2StringDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/CompactNumberArray2StringDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/CompactNumberArray2StringDecomposer.cs	(revision 1625)
@@ -61,42 +61,49 @@
 
     public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
-      var tagIter = metaInfo.GetEnumerator();
-      tagIter.MoveNext();
-      var valueIter = ((string)tagIter.Current.Value)
-        .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
-        .GetEnumerator();
-      valueIter.MoveNext();
-      int rank = int.Parse((string)valueIter.Current);
-      int[] lengths = new int[rank];
-      int[] lowerBounds = new int[rank];
-      for (int i = 0; i < rank; i++) {
+      try {
+        var tagIter = metaInfo.GetEnumerator();
+        tagIter.MoveNext();      
+        var valueIter = ((string)tagIter.Current.Value)
+          .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
+          .GetEnumerator();
         valueIter.MoveNext();
-        lengths[i] = int.Parse((string)valueIter.Current);
-      }
-      for (int i = 0; i < rank; i++) {
-        valueIter.MoveNext();
-        lowerBounds[i] = int.Parse((string)valueIter.Current);
-      }
-      Type elementType = type.GetElementType();
-      Array a = Array.CreateInstance(elementType, lengths, lowerBounds);
-      int[] positions = (int[])lowerBounds.Clone();
-      while (valueIter.MoveNext()) {
-        a.SetValue(
-          numberConverter.Parse((string)valueIter.Current, elementType),
-          positions);
-        positions[0] += 1;
-        for (int i = 0; i < rank - 1; i++) {
-          if (positions[i] >= lengths[i] + lowerBounds[i]) {
-            positions[i + 1] += 1;
-            positions[i] = lowerBounds[i];
-          } else {
-            break;
+        int rank = int.Parse((string)valueIter.Current);
+        int[] lengths = new int[rank];
+        int[] lowerBounds = new int[rank];
+        for (int i = 0; i < rank; i++) {
+          valueIter.MoveNext();
+          lengths[i] = int.Parse((string)valueIter.Current);
+        }
+        for (int i = 0; i < rank; i++) {
+          valueIter.MoveNext();
+          lowerBounds[i] = int.Parse((string)valueIter.Current);
+        }
+        Type elementType = type.GetElementType();
+        Array a = Array.CreateInstance(elementType, lengths, lowerBounds);
+        int[] positions = (int[])lowerBounds.Clone();
+        while (valueIter.MoveNext()) {
+          a.SetValue(
+            numberConverter.Parse((string)valueIter.Current, elementType),
+            positions);
+          positions[0] += 1;
+          for (int i = 0; i < rank - 1; i++) {
+            if (positions[i] >= lengths[i] + lowerBounds[i]) {
+              positions[i + 1] += 1;
+              positions[i] = lowerBounds[i];
+            } else {
+              break;
+            }
           }
         }
-      }
-      return a;
+        return a;
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("Insufficient data to deserialize compact array", e);
+      } catch (InvalidCastException e) {
+        throw new PersistenceException("Invalid element data during compact array deserialization", e);
+      }      
     }
 
     public void Populate(object instance, IEnumerable<Tag> tags, Type type) {
+      // Nothing to do: Compact arrays are already populated during instance creation.
     }
 
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/DictionaryDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/DictionaryDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/DictionaryDecomposer.cs	(revision 1625)
@@ -39,10 +39,20 @@
       IDictionary dict = (IDictionary)instance;
       IEnumerator<Tag> iter = o.GetEnumerator();
-      while (iter.MoveNext()) {
-        Tag key = iter.Current;
-        iter.MoveNext();
-        Tag value = iter.Current;
-        dict.Add(key.Value, value.Value);
-      }
+      try {
+        while (iter.MoveNext()) {
+          Tag key = iter.Current;
+          iter.MoveNext();
+          Tag value = iter.Current;
+          dict.Add(key.Value, value.Value);
+        }
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("Dictionaries must contain an even number of elements (key+value).", e);
+      } catch (NotSupportedException e) {
+        throw new PersistenceException("The serialized dictionary type was read-only or had a fixed size and cannot be deserialized.", e);
+      } catch (ArgumentNullException e) {
+        throw new PersistenceException("Dictionary key was null.", e);
+      } catch (ArgumentException e) {
+        throw new PersistenceException("Duplicate dictionary key.", e);
+      }      
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumDecomposer.cs	(revision 1625)
@@ -28,9 +28,16 @@
     public object CreateInstance(Type t, IEnumerable<Tag> metaInfo) {
       IEnumerator<Tag> it = metaInfo.GetEnumerator();
-      it.MoveNext();
-      return Enum.Parse(t, (string)it.Current.Value);
+      try {
+        it.MoveNext();
+        return Enum.Parse(t, (string)it.Current.Value);
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("not enough meta information to recstruct enum", e);
+      } catch (InvalidCastException e) {
+        throw new PersistenceException("invalid meta information found while trying to reconstruct enum", e);
+      }
     }
 
     public void Populate(object instance, IEnumerable<Tag> elements, Type t) {
+      // Enums are already populated during instance creation.
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumerableDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumerableDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumerableDecomposer.cs	(revision 1625)
@@ -45,6 +45,10 @@
     public void Populate(object instance, IEnumerable<Tag> tags, Type type) {
       MethodInfo addMethod = type.GetMethod("Add");
-      foreach (var tag in tags)
-        addMethod.Invoke(instance, new[] { tag.Value });
+      try {
+        foreach (var tag in tags)
+          addMethod.Invoke(instance, new[] { tag.Value });
+      } catch (Exception e) {
+        throw new PersistenceException("Exception caught while trying to populate enumerable.", e);
+      }
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/KeyValuePairDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/KeyValuePairDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/KeyValuePairDecomposer.cs	(revision 1625)
@@ -29,6 +29,17 @@
     public IEnumerable<Tag> Decompose(object o) {
       Type t = o.GetType();
-      yield return new Tag("key", t.GetProperty("Key").GetValue(o, null));
-      yield return new Tag("value", t.GetProperty("Value").GetValue(o, null));
+      Tag key, value;
+      try {
+        key = new Tag("key", t.GetProperty("Key").GetValue(o, null));        
+      } catch (Exception e) {
+        throw new PersistenceException("Exception caught during KeyValuePair decomposition", e);
+      }
+      yield return key;
+      try {
+        value = new Tag("value", t.GetProperty("Value").GetValue(o, null));
+      } catch (Exception e) {
+        throw new PersistenceException("Exception caught during KeyValuePair decomposition", e);
+      }
+      yield return value;
     }
 
@@ -39,10 +50,16 @@
     public void Populate(object instance, IEnumerable<Tag> o, Type t) {
       IEnumerator<Tag> iter = o.GetEnumerator();
-      iter.MoveNext();
-      t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-        .Single(fi => fi.Name == "key").SetValue(instance, iter.Current.Value);
-      iter.MoveNext();
-      t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-        .Single(fi => fi.Name == "value").SetValue(instance, iter.Current.Value);
+      try {
+        iter.MoveNext();
+        t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+          .Single(fi => fi.Name == "key").SetValue(instance, iter.Current.Value);
+        iter.MoveNext();
+        t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+          .Single(fi => fi.Name == "value").SetValue(instance, iter.Current.Value);
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("Not enough components to populate KeyValuePair instance", e);
+      } catch (Exception e) {
+        throw new PersistenceException("Exception caught during KeyValuePair reconstruction", e);
+      }
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Number2StringConverter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Number2StringConverter.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Number2StringConverter.cs	(revision 1625)
@@ -53,8 +53,14 @@
 
     public object Parse(string stringValue, Type type) {
-      return numberParsers[type]
-        .Invoke(null,
-            BindingFlags.Static | BindingFlags.PutRefDispProperty,
-                  null, new[] { stringValue }, CultureInfo.InvariantCulture);
+      try {        
+        return numberParsers[type]
+          .Invoke(null,
+              BindingFlags.Static | BindingFlags.PutRefDispProperty,
+                    null, new[] { stringValue }, CultureInfo.InvariantCulture);
+      } catch (FormatException e) {
+        throw new PersistenceException("Invalid element data during number parsing.", e);
+      } catch (OverflowException e) {
+        throw new PersistenceException("Overflow during number parsing.", e);
+      } 
     }
 
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/NumberEnumerable2StringDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/NumberEnumerable2StringDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/NumberEnumerable2StringDecomposer.cs	(revision 1625)
@@ -91,10 +91,16 @@
       Type elementType = enumerable.GetGenericArguments()[0];
       MethodInfo addMethod = type.GetMethod("Add");
-      var tagEnumerator = tags.GetEnumerator();
-      tagEnumerator.MoveNext();
-      string[] stringValues = ((string)tagEnumerator.Current.Value)
-        .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
-      foreach (var value in stringValues) {
-        addMethod.Invoke(instance, new[] { numberConverter.Parse(value, elementType) });
+      try {
+        var tagEnumerator = tags.GetEnumerator();
+        tagEnumerator.MoveNext();
+        string[] stringValues = ((string)tagEnumerator.Current.Value)
+          .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+        foreach (var value in stringValues) {
+          addMethod.Invoke(instance, new[] { numberConverter.Parse(value, elementType) });
+        }
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("Insufficient element data to reconstruct number enumerable", e);
+      } catch (InvalidCastException e) {
+        throw new PersistenceException("Invalid element data during reconstruction of number enumerable", e);
       }
     }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Storable/DataMemberAccessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Storable/DataMemberAccessor.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Storable/DataMemberAccessor.cs	(revision 1625)
@@ -1,4 +1,5 @@
 ﻿using System;
 using System.Reflection;
+using HeuristicLab.Persistence.Core;
 
 namespace HeuristicLab.Persistence.Default.Decomposers.Storable {
@@ -22,5 +23,5 @@
         PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
         if (!propertyInfo.CanRead || !propertyInfo.CanWrite) {
-          throw new NotSupportedException(
+          throw new PersistenceException(
             "Storable properties must implement both a Get and a Set Accessor. ");
         }
@@ -28,5 +29,5 @@
         Set = value => propertyInfo.SetValue(obj, value, null);
       } else {
-        throw new NotSupportedException(
+        throw new PersistenceException(
           "The Storable attribute can only be applied to fields and properties.");
       }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/TypeDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/TypeDecomposer.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/TypeDecomposer.cs	(revision 1625)
@@ -28,11 +28,23 @@
 
     public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
-      foreach (var typeName in metaInfo) {
-        return Type.GetType((string)typeName.Value);
+      IEnumerator<Tag> it = metaInfo.GetEnumerator();
+      try {
+        it.MoveNext();
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("Insufficient meta information to instantiate Type object", e);
       }
-      return null;
+      try {
+        return Type.GetType((string)it.Current.Value, true);
+      } catch (InvalidCastException e) {
+        throw new PersistenceException("Invalid meta information during reconstruction of Type object", e);
+      } catch (TypeLoadException e) {
+        throw new PersistenceException(String.Format(
+          "Cannot load Type {0}, make sure all required assemblies are available.",
+          (string)it.Current.Value), e);
+      }
     }
 
     public void Populate(object instance, IEnumerable<Tag> objects, Type type) {
+      // Type ojects are populated during instance creation.
     }
   }
Index: unk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/X2StringDecomposer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/X2StringDecomposer.cs	(revision 1624)
+++ 	(revision )
@@ -1,278 +1,0 @@
-﻿using System;
-using HeuristicLab.Persistence.Interfaces;
-using HeuristicLab.Persistence.Core;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Globalization;
-using System.Text;
-
-namespace HeuristicLab.Persistence.Default.Decomposers {
-
-  public class Number2StringConverter {
-
-    private static readonly List<Type> numberTypes =
-      new List<Type> {
-        typeof(bool),
-        typeof(byte),
-        typeof(sbyte),
-        typeof(short),
-        typeof(ushort),
-        typeof(int),
-        typeof(uint),
-        typeof(long),
-        typeof(ulong),
-        typeof(float),
-        typeof(double),
-        typeof(decimal),
-      };
-
-    private static readonly Dictionary<Type, MethodInfo> numberParsers;
-
-    static Number2StringConverter() {
-      numberParsers = new Dictionary<Type, MethodInfo>();
-      foreach (var type in numberTypes) {
-        numberParsers[type] = type
-          .GetMethod("Parse", BindingFlags.Static | BindingFlags.Public,
-                     null, new[] { typeof(string) }, null);
-      }
-    }
-
-    public bool CanDecompose(Type type) {
-      return numberParsers.ContainsKey(type);
-    }
-
-    public string Format(object obj) {
-      if (obj.GetType() == typeof(float))
-        return ((float)obj).ToString("r", CultureInfo.InvariantCulture);
-      if (obj.GetType() == typeof(double))
-        return ((double)obj).ToString("r", CultureInfo.InvariantCulture);
-      if (obj.GetType() == typeof(decimal))
-        return ((decimal)obj).ToString("r", CultureInfo.InvariantCulture);
-      return obj.ToString();
-    }
-
-    public object Parse(string stringValue, Type type) {
-      return numberParsers[type]
-        .Invoke(null,
-            BindingFlags.Static | BindingFlags.PutRefDispProperty,
-                  null, new[] { stringValue }, CultureInfo.InvariantCulture);
-    }
-
-  }
-
-  [EmptyStorableClass]
-  public class DateTime2StringDecomposer : IDecomposer {
-
-    public int Priority {
-      get { return 100; }
-    }
-
-
-    public bool CanDecompose(Type type) {
-      return type == typeof(DateTime);
-    }
-
-    public IEnumerable<Tag> CreateMetaInfo(object obj) {
-      yield return new Tag(((DateTime)obj).Ticks);
-    }
-
-    public IEnumerable<Tag> Decompose(object obj) {
-      return new Tag[] { };
-    }
-
-    public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
-      foreach (Tag tag in metaInfo) {
-        return new DateTime((long)tag.Value);
-      }
-      throw new ApplicationException("Not enough components to compose a bool.");
-    }
-
-    public void Populate(object instance, IEnumerable<Tag> tags, Type type) {
-    }
-
-  }
-
-  [EmptyStorableClass]
-  public class CompactNumberArray2StringDecomposer : IDecomposer {
-
-    public int Priority {
-      get { return 200; }
-    }
-
-    private static readonly Number2StringConverter numberConverter =
-      new Number2StringConverter();
-
-    public bool CanDecompose(Type type) {
-      return
-        (type.IsArray || type == typeof(Array)) &&
-        numberConverter.CanDecompose(type.GetElementType());
-    }
-
-    public IEnumerable<Tag> CreateMetaInfo(object obj) {
-      Array a = (Array)obj;
-      int[] lengths = new int[a.Rank];
-      int[] lowerBounds = new int[a.Rank];
-      StringBuilder sb = new StringBuilder();
-      sb.Append(a.Rank).Append(';');
-      for (int i = 0; i < a.Rank; i++) {
-        sb.Append(a.GetLength(i)).Append(';');
-        lengths[i] = a.GetLength(i);
-      }
-      for (int i = 0; i < a.Rank; i++) {
-        sb.Append(a.GetLowerBound(i)).Append(';');
-        lowerBounds[i] = a.GetLowerBound(i);
-      }
-      int[] positions = (int[])lowerBounds.Clone();
-      while (positions[a.Rank - 1] < lengths[a.Rank - 1] + lowerBounds[a.Rank - 1]) {
-        sb.Append(numberConverter.Format(a.GetValue(positions))).Append(';');
-        positions[0] += 1;
-        for (int i = 0; i < a.Rank - 1; i++) {
-          if (positions[i] >= lengths[i] + lowerBounds[i]) {
-            positions[i] = lowerBounds[i];
-            positions[i + 1] += 1;
-          } else {
-            break;
-          }
-        }
-      }
-      yield return new Tag("compact array", sb.ToString());
-    }
-
-    public IEnumerable<Tag> Decompose(object obj) {
-      return new Tag[] { };
-    }
-
-    public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
-      var tagIter = metaInfo.GetEnumerator();
-      tagIter.MoveNext();
-      var valueIter = ((string)tagIter.Current.Value)
-        .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
-        .GetEnumerator();
-      valueIter.MoveNext();
-      int rank = int.Parse((string)valueIter.Current);
-      int[] lengths = new int[rank];
-      int[] lowerBounds = new int[rank];
-      for (int i = 0; i < rank; i++) {
-        valueIter.MoveNext();
-        lengths[i] = int.Parse((string)valueIter.Current);
-      }
-      for (int i = 0; i < rank; i++) {
-        valueIter.MoveNext();
-        lowerBounds[i] = int.Parse((string)valueIter.Current);
-      }
-      Type elementType = type.GetElementType();
-      Array a = Array.CreateInstance(elementType, lengths, lowerBounds);
-      int[] positions = (int[])lowerBounds.Clone();
-      while (valueIter.MoveNext()) {
-        a.SetValue(
-          numberConverter.Parse((string)valueIter.Current, elementType),
-          positions);
-        positions[0] += 1;
-        for (int i = 0; i < rank - 1; i++) {
-          if (positions[i] >= lengths[i] + lowerBounds[i]) {
-            positions[i + 1] += 1;
-            positions[i] = lowerBounds[i];
-          } else {
-            break;
-          }
-        }
-      }
-      return a;
-    }
-
-    public void Populate(object instance, IEnumerable<Tag> tags, Type type) {
-    }
-
-  }
-
-  [EmptyStorableClass]
-  public class NumberEnumerable2StringDecomposer : IDecomposer {
-
-    public int Priority {
-      get { return 200; }
-    }
-
-    private static readonly Number2StringConverter numberConverter =
-      new Number2StringConverter();
-
-    private static readonly Dictionary<Type, Type> interfaceCache = new Dictionary<Type, Type>();
-
-    public Type GetGenericEnumerableInterface(Type type) {
-      if (interfaceCache.ContainsKey(type))
-        return interfaceCache[type];
-      foreach (Type iface in type.GetInterfaces()) {
-        if (iface.IsGenericType &&
-          iface.GetGenericTypeDefinition() == typeof(IEnumerable<>) &&
-          numberConverter.CanDecompose(iface.GetGenericArguments()[0])) {
-          interfaceCache.Add(type, iface);
-          return iface;
-        }
-      }
-      interfaceCache.Add(type, null);
-      return null;
-    }
-
-    public bool ImplementsGenericEnumerable(Type type) {
-      return GetGenericEnumerableInterface(type) != null;
-    }
-
-    public bool HasAddMethod(Type type) {
-      return
-        type.GetMethod("Add") != null &&
-        type.GetMethod("Add").GetParameters().Length == 1 &&
-        type.GetConstructor(
-          BindingFlags.Public |
-          BindingFlags.NonPublic |
-          BindingFlags.Instance,
-          null, Type.EmptyTypes, null) != null;
-    }
-
-    public bool CanDecompose(Type type) {
-      return
-        ImplementsGenericEnumerable(type) &&
-        HasAddMethod(type);
-    }
-
-    public IEnumerable<Tag> CreateMetaInfo(object o) {
-      return new Tag[] { };
-    }
-
-    public IEnumerable<Tag> Decompose(object obj) {
-      Type type = obj.GetType();
-      Type enumerable = GetGenericEnumerableInterface(type);
-      InterfaceMapping iMap = obj.GetType().GetInterfaceMap(enumerable);
-      MethodInfo getEnumeratorMethod =
-        iMap.TargetMethods[
-        Array.IndexOf(
-          iMap.InterfaceMethods,
-          enumerable.GetMethod("GetEnumerator"))];
-      object[] empty = new object[] { };
-      object genericEnumerator = getEnumeratorMethod.Invoke(obj, empty);
-      MethodInfo moveNextMethod = genericEnumerator.GetType().GetMethod("MoveNext");
-      PropertyInfo currentProperty = genericEnumerator.GetType().GetProperty("Current");
-      StringBuilder sb = new StringBuilder();
-      while ((bool)moveNextMethod.Invoke(genericEnumerator, empty))
-        sb.Append(
-          numberConverter.Format(
-            currentProperty.GetValue(genericEnumerator, null))).Append(';');
-      yield return new Tag("compact enumerable", sb.ToString());
-    }
-
-    public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
-      return Activator.CreateInstance(type, true);
-    }
-
-    public void Populate(object instance, IEnumerable<Tag> tags, Type type) {
-      Type enumerable = GetGenericEnumerableInterface(type);
-      Type elementType = enumerable.GetGenericArguments()[0];
-      MethodInfo addMethod = type.GetMethod("Add");
-      var tagEnumerator = tags.GetEnumerator();
-      tagEnumerator.MoveNext();
-      string[] stringValues = ((string)tagEnumerator.Current.Value)
-        .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
-      foreach (var value in stringValues) {
-        addMethod.Invoke(instance, new[] { numberConverter.Parse(value, elementType) });
-      }
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/DoubleArray2XmlFormatters.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/DoubleArray2XmlFormatters.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/DoubleArray2XmlFormatters.cs	(revision 1625)
@@ -2,4 +2,5 @@
 using HeuristicLab.Persistence.Core;
 using System.Globalization;
+using HeuristicLab.Persistence.Default.Decomposers.Storable;
 
 namespace HeuristicLab.Persistence.Default.Xml.Compact {
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/IntArray2XmlFormatters.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/IntArray2XmlFormatters.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/IntArray2XmlFormatters.cs	(revision 1625)
@@ -1,4 +1,5 @@
 ﻿using System;
 using HeuristicLab.Persistence.Core;
+using HeuristicLab.Persistence.Default.Decomposers.Storable;
 
 namespace HeuristicLab.Persistence.Default.Xml.Compact {
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberArray2XmlFormatterBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberArray2XmlFormatterBase.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberArray2XmlFormatterBase.cs	(revision 1625)
@@ -3,4 +3,5 @@
 using HeuristicLab.Persistence.Interfaces;
 using System;
+using HeuristicLab.Persistence.Core;
 
 namespace HeuristicLab.Persistence.Default.Xml.Compact {
@@ -46,34 +47,44 @@
 
     public override T Parse(XmlString x) {
-      IEnumerator values =
-        x.Data.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++) {
+      try {
+        IEnumerator values =
+          x.Data.Split(new[] { Separator },
+          StringSplitOptions.RemoveEmptyEntries).GetEnumerator();
         values.MoveNext();
-        lengths[i] = int.Parse((string)values.Current);
-      }
-      int[] lowerBounds = new int[rank];
-      for (int i = 0; i < rank; i++) {
-        values.MoveNext();
-        lowerBounds[i] = int.Parse((string)values.Current);
-      }
-      Array a = Array.CreateInstance(this.SourceType.GetElementType(), lengths, lowerBounds);
-      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;
+        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);
+        }
+        int[] lowerBounds = new int[rank];
+        for (int i = 0; i < rank; i++) {
+          values.MoveNext();
+          lowerBounds[i] = int.Parse((string)values.Current);
+        }
+        Array a = Array.CreateInstance(this.SourceType.GetElementType(), lengths, lowerBounds);
+        int[] positions = (int[])lowerBounds.Clone();
+        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 (T)(object)a;
+        if (positions[rank - 1] != lowerBounds[rank - 1] + lengths[rank - 1])
+          throw new PersistenceException("Insufficient number of elements while trying to fill number array.");
+        return (T)(object)a;
+      } catch (InvalidOperationException e) {
+        throw new PersistenceException("Insufficient information to rebuild number array.", e);
+      } catch (InvalidCastException e) {
+        throw new PersistenceException("Invalid element data or meta data to reconstruct number array.", e);
+      } catch (OverflowException e) {
+        throw new PersistenceException("Overflow during element parsing while trying to reconstruct number array.", e);
+      } 
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberEnumeration2XmlFormatterBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberEnumeration2XmlFormatterBase.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberEnumeration2XmlFormatterBase.cs	(revision 1625)
@@ -3,4 +3,5 @@
 using HeuristicLab.Persistence.Interfaces;
 using System;
+using HeuristicLab.Persistence.Core;
 
 namespace HeuristicLab.Persistence.Default.Xml.Compact {
@@ -24,10 +25,16 @@
 
     public override T Parse(XmlString x) {
-      IEnumerable enumeration = Instantiate();
-      string[] values = x.Data.Split(new[] { Separator }, StringSplitOptions.RemoveEmptyEntries);
-      foreach (var value in values) {
-        Add(enumeration, ParseValue(value));
-      }
-      return (T)enumeration;
+      try {
+        IEnumerable enumeration = Instantiate();
+        string[] values = x.Data.Split(new[] { Separator }, StringSplitOptions.RemoveEmptyEntries);
+        foreach (var value in values) {
+          Add(enumeration, ParseValue(value));
+        }
+        return (T)enumeration;
+      } catch (InvalidCastException e) {
+        throw new PersistenceException("Invalid element data during reconstruction of number enumerable.", e);
+      } catch (OverflowException e) {
+        throw new PersistenceException("Overflow during element parsing while trying to reconstruct number enumerable.", e);
+      }       
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DateTime2XmlFormatter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DateTime2XmlFormatter.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DateTime2XmlFormatter.cs	(revision 1625)
@@ -14,5 +14,9 @@
 
     public override DateTime Parse(XmlString x) {
-      return new DateTime(long.Parse(x.Data));
+      try {
+        return new DateTime(long.Parse(x.Data));
+      } catch (Exception e) {
+        throw new PersistenceException("Exception caugth while trying to reconstruct DateTime object.", e);
+      }
     }
 
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DecimalNumber2XmlFormatterBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DecimalNumber2XmlFormatterBase.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DecimalNumber2XmlFormatterBase.cs	(revision 1625)
@@ -31,5 +31,9 @@
     }
     public override T Parse(XmlString x) {
-      return (T)ParseMethod.Invoke(null, new object[] { x.Data, CultureInfo.InvariantCulture });
+      try {
+        return (T)ParseMethod.Invoke(null, new object[] { x.Data, CultureInfo.InvariantCulture });
+      } catch (Exception e) {
+        throw new PersistenceException("Could not parse decimal number.", e);
+      }
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/SimpleNumber2XmlFormatterBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/SimpleNumber2XmlFormatterBase.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/SimpleNumber2XmlFormatterBase.cs	(revision 1625)
@@ -22,5 +22,9 @@
     }
     public override T Parse(XmlString x) {
-      return (T)ParseMethod.Invoke(null, new[] { x.Data });
+      try {
+        return (T)ParseMethod.Invoke(null, new[] { x.Data });
+      } catch (Exception e) {
+        throw new PersistenceException("Could not parse simple number.", e);
+      }
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlFormatter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlFormatter.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlFormatter.cs	(revision 1625)
@@ -26,4 +26,7 @@
         sb.Append(m.Groups[1]);
       }
+      string result = sb.ToString();
+      if (result.Length == 0 && x.Data.Length > 0 && !x.Data.Equals("<![CDATA[]]>"))
+        throw new PersistenceException("Invalid CDATA section during string parsing.");
       return sb.ToString();
     }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs	(revision 1625)
@@ -161,27 +161,32 @@
 
     public static void Serialize(object obj, string filename, Configuration config) {
-      Serializer serializer = new Serializer(obj, config);
-      XmlGenerator generator = new XmlGenerator();
-      ZipOutputStream zipStream = new ZipOutputStream(File.Create(filename));
-      zipStream.SetLevel(9);
-      zipStream.PutNextEntry(new ZipEntry("data.xml"));
-      StreamWriter writer = new StreamWriter(zipStream);
-      ILog logger = Logger.GetDefaultLogger();
-      foreach (ISerializationToken token in serializer) {
-        string line = generator.Format(token);
-        writer.Write(line);
-        logger.Debug(line.TrimEnd());
+      try {
+        Serializer serializer = new Serializer(obj, config);
+        XmlGenerator generator = new XmlGenerator();
+        ZipOutputStream zipStream = new ZipOutputStream(File.Create(filename));
+        zipStream.SetLevel(9);
+        zipStream.PutNextEntry(new ZipEntry("data.xml"));
+        StreamWriter writer = new StreamWriter(zipStream);
+        ILog logger = Logger.GetDefaultLogger();
+        foreach (ISerializationToken token in serializer) {
+          string line = generator.Format(token);
+          writer.Write(line);
+          logger.Debug(line.TrimEnd());
+        }
+        writer.Flush();
+        zipStream.PutNextEntry(new ZipEntry("typecache.xml"));
+        writer = new StreamWriter(zipStream);
+        foreach (string line in generator.Format(serializer.TypeCache)) {
+          writer.Write(line);
+          logger.Debug(line.TrimEnd());
+        }
+        writer.Flush();
+        zipStream.Close();
+      } catch (PersistenceException e) {
+        throw;
+      } catch (Exception e) {
+        throw new PersistenceException("Unexpected exception during Serialization.", e);
       }
-      writer.Flush();
-      zipStream.PutNextEntry(new ZipEntry("typecache.xml"));
-      writer = new StreamWriter(zipStream);
-      foreach (string line in generator.Format(serializer.TypeCache)) {
-        writer.Write(line);
-        logger.Debug(line.TrimEnd());
-      }
-      writer.Flush();
-      zipStream.Close();
     }
-
   }
 }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlParser.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlParser.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlParser.cs	(revision 1625)
@@ -42,6 +42,6 @@
           iterator = handlers[reader.Name].Invoke();
         } catch (KeyNotFoundException) {
-          throw new InvalidOperationException(String.Format(
-            "No handler for XML tag \"{0}\" installed",
+          throw new PersistenceException(String.Format(
+            "Invalid XML tag \"{0}\" in persistence file.",
             reader.Name));
         }
@@ -103,28 +103,40 @@
 
     public static List<TypeMapping> ParseTypeCache(TextReader reader) {
-      var typeCache = new List<TypeMapping>();
-      XmlReader xmlReader = XmlReader.Create(reader);
-      while (xmlReader.Read()) {
-        if (xmlReader.Name == XmlStringConstants.TYPE) {
-          typeCache.Add(new TypeMapping(
-            int.Parse(xmlReader.GetAttribute("id")),
-            xmlReader.GetAttribute("typeName"),
-            xmlReader.GetAttribute("serializer")));
+      try {
+        var typeCache = new List<TypeMapping>();
+        XmlReader xmlReader = XmlReader.Create(reader);
+        while (xmlReader.Read()) {
+          if (xmlReader.Name == XmlStringConstants.TYPE) {
+            typeCache.Add(new TypeMapping(
+              int.Parse(xmlReader.GetAttribute("id")),
+              xmlReader.GetAttribute("typeName"),
+              xmlReader.GetAttribute("serializer")));
+          }
         }
+        return typeCache;
+      } catch (PersistenceException e) {
+        throw;
+      } catch (Exception e) {
+        throw new PersistenceException("Unexpected exception during type cache parsing.", e);
       }
-      return typeCache;
     }
 
     public static object DeSerialize(string filename) {
-      ZipFile zipFile = new ZipFile(filename);
-      Deserializer deSerializer = new Deserializer(
-        ParseTypeCache(
-        new StreamReader(
-          zipFile.GetInputStream(zipFile.GetEntry("typecache.xml")))));
-      XmlParser parser = new XmlParser(
-        new StreamReader(zipFile.GetInputStream(zipFile.GetEntry("data.xml"))));
-      object result = deSerializer.Deserialize(parser);
-      zipFile.Close();
-      return result;
+      try {
+        ZipFile zipFile = new ZipFile(filename);
+        Deserializer deSerializer = new Deserializer(
+          ParseTypeCache(
+          new StreamReader(
+            zipFile.GetInputStream(zipFile.GetEntry("typecache.xml")))));
+        XmlParser parser = new XmlParser(
+          new StreamReader(zipFile.GetInputStream(zipFile.GetEntry("data.xml"))));
+        object result = deSerializer.Deserialize(parser);
+        zipFile.Close();
+        return result;
+      } catch (PersistenceException e) {
+        throw;
+      } catch (Exception e) {
+        throw new PersistenceException("Unexpected exception during deserialization", e);
+      }
     }
   }
Index: /trunk/sources/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj	(revision 1625)
@@ -94,4 +94,6 @@
   <ItemGroup>
     <Compile Include="Core\Configuration.cs" />
+    <Compile Include="Core\PersistenceException.cs" />
+    <Compile Include="Default\Decomposers\Number2StringConverter.cs" />
     <Compile Include="Default\Decomposers\Storable\EmptyStorableClassAttribute.cs" />
     <Compile Include="Core\FormatBase.cs" />
@@ -120,5 +122,4 @@
     <Compile Include="Default\DebugString\DebugStringGenerator.cs" />
     <Compile Include="Default\Decomposers\ArrayDecomposer.cs" />
-    <Compile Include="Default\Decomposers\Number2StringConverter.cs" />
     <Compile Include="Default\Decomposers\CompactNumberArray2StringDecomposer.cs" />
     <Compile Include="Default\Decomposers\EnumerableDecomposer.cs" />
Index: /trunk/sources/HeuristicLab.Persistence/UnitTests/StorableAttributeTests.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/UnitTests/StorableAttributeTests.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/UnitTests/StorableAttributeTests.cs	(revision 1625)
@@ -3,4 +3,5 @@
 using HeuristicLab.Persistence.Core;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Persistence.Default.Decomposers.Storable;
 
 namespace HeuristicLab.Persistence.Test {
Index: /trunk/sources/HeuristicLab.Persistence/UnitTests/UseCases.cs
===================================================================
--- /trunk/sources/HeuristicLab.Persistence/UnitTests/UseCases.cs	(revision 1624)
+++ /trunk/sources/HeuristicLab.Persistence/UnitTests/UseCases.cs	(revision 1625)
@@ -10,4 +10,5 @@
 using System.IO;
 using System.Reflection;
+using HeuristicLab.Persistence.Default.Decomposers.Storable;
 
 namespace HeuristicLab.Persistence.UnitTest {
