Index: branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Number2StringSerializer.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Number2StringSerializer.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Number2StringSerializer.cs	(revision 11009)
@@ -78,5 +78,5 @@
     /// </returns>
     public bool CanSerialize(Type type) {
-      return numberSerializerMap.ContainsKey(type);
+      return numberSerializerMap.ContainsKey(Nullable.GetUnderlyingType(type) ?? type);
     }
 
@@ -90,5 +90,5 @@
     /// </returns>
     public string JustifyRejection(Type type) {
-      return string.Format("not a number type (one of {0})",
+      return string.Format("not a (nullable) number type (one of {0})",
         string.Join(", ", numberSerializers.Select(n => n.SourceType.Name).ToArray()));
     }
@@ -100,5 +100,7 @@
     /// <returns></returns>
     public string Format(object obj) {
-      return ((XmlString)numberSerializerMap[obj.GetType()].Format(obj)).Data;
+      if (obj == null) return "null";
+      Type type = obj.GetType();
+      return ((XmlString)numberSerializerMap[Nullable.GetUnderlyingType(type) ?? type].Format(obj)).Data;
     }
 
@@ -110,6 +112,7 @@
     /// <returns></returns>
     public object Parse(string stringValue, Type type) {
+      if (stringValue == "null") return null;
       try {
-        return numberSerializerMap[type].Parse(new XmlString(stringValue));
+        return numberSerializerMap[Nullable.GetUnderlyingType(type) ?? type].Parse(new XmlString(stringValue));
       }
       catch (FormatException e) {
Index: branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs	(revision 11009)
@@ -47,4 +47,5 @@
       hookCache = new Dictionary<HookDesignator, List<StorableReflection.Hook>>();
     }
+
     [StorableConstructor]
     private StorableSerializer(bool deserializing) : this() { }
@@ -68,5 +69,5 @@
     /// </returns>
     public bool CanSerialize(Type type) {
-      bool markedStorable = StorableReflection.HasStorableClassAttribute(type);
+      var markedStorable = StorableReflection.HasStorableClassAttribute(type);
       if (GetConstructor(type) == null)
         if (markedStorable)
@@ -91,5 +92,5 @@
     /// </returns>
     public string JustifyRejection(Type type) {
-      StringBuilder sb = new StringBuilder();
+      var sb = new StringBuilder();
       if (GetConstructor(type) == null)
         sb.Append("class has no default constructor and no [StorableConstructor]");
@@ -117,8 +118,7 @@
     /// <returns>An enumerable of <see cref="Tag"/>s.</returns>
     public IEnumerable<Tag> Decompose(object obj) {
-      foreach (var accessor in GetStorableAccessors(obj.GetType())) {
-        if (accessor.Get != null)
-          yield return new Tag(accessor.Name, accessor.Get(obj));
-      }
+      return from accessor in GetStorableAccessors(obj.GetType())
+             where accessor.Get != null
+             select new Tag(accessor.Name, accessor.Get(obj));
     }
 
@@ -147,5 +147,5 @@
     public void Populate(object instance, IEnumerable<Tag> objects, Type type) {
       var memberDict = new Dictionary<string, Tag>();
-      IEnumerator<Tag> iter = objects.GetEnumerator();
+      var iter = objects.GetEnumerator();
       while (iter.MoveNext()) {
         memberDict.Add(iter.Current.Name, iter.Current);
@@ -170,15 +170,6 @@
       BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
 
-    private static readonly object[] emptyArgs = new object[] { };
-    private static readonly object[] trueArgs = new object[] { true };
-
-    private sealed class HookDesignator {
-      public Type Type { get; private set; }
-      public HookType HookType { get; private set; }
-      public HookDesignator() { }
-      public HookDesignator(Type type, HookType hookType) {
-        Type = type;
-        HookType = HookType;
-      }
+    private sealed class HookDesignator : Tuple<Type, HookType> {
+      public HookDesignator(Type type, HookType hookType) : base(type, hookType) { }
     }
 
@@ -191,8 +182,8 @@
     #region caches
 
-    private AccessorListCache accessorListCache;
-    private AccessorCache accessorCache;
-    private Dictionary<Type, Constructor> constructorCache;
-    private Dictionary<HookDesignator, List<StorableReflection.Hook>> hookCache;
+    private readonly AccessorListCache accessorListCache;
+    private readonly AccessorCache accessorCache;
+    private readonly Dictionary<Type, Constructor> constructorCache;
+    private readonly Dictionary<HookDesignator, List<StorableReflection.Hook>> hookCache;
 
     #endregion
@@ -206,5 +197,6 @@
         var storableMembers = StorableReflection
           .GenerateStorableMembers(type)
-          .Select(mi => GetMemberAccessor(mi));
+          .Select(GetMemberAccessor)
+          .ToList();
         accessorListCache[type] = storableMembers;
         return storableMembers;
@@ -216,5 +208,5 @@
         if (accessorCache.ContainsKey(mi.MemberInfo))
           return new DataMemberAccessor(accessorCache[mi.MemberInfo], mi.DisentangledName, mi.DefaultValue);
-        DataMemberAccessor dma = new DataMemberAccessor(mi.MemberInfo, mi.DisentangledName, mi.DefaultValue);
+        var dma = new DataMemberAccessor(mi.MemberInfo, mi.DisentangledName, mi.DefaultValue);
         accessorCache[mi.MemberInfo] = dma;
         return dma;
@@ -226,5 +218,5 @@
         if (constructorCache.ContainsKey(type))
           return constructorCache[type];
-        Constructor c = FindStorableConstructor(type) ?? GetDefaultConstructor(type);
+        var c = FindStorableConstructor(type) ?? GetDefaultConstructor(type);
         constructorCache.Add(type, c);
         return c;
@@ -233,9 +225,9 @@
 
     private Constructor GetDefaultConstructor(Type type) {
-      ConstructorInfo ci = type.GetConstructor(ALL_CONSTRUCTORS, null, Type.EmptyTypes, null);
+      var ci = type.GetConstructor(ALL_CONSTRUCTORS, null, Type.EmptyTypes, null);
       if (ci == null)
         return null;
-      DynamicMethod dm = new DynamicMethod("", typeof(object), null, type, true);
-      ILGenerator ilgen = dm.GetILGenerator();
+      var dm = new DynamicMethod("", typeof(object), null, type, true);
+      var ilgen = dm.GetILGenerator();
       ilgen.Emit(OpCodes.Newobj, ci);
       ilgen.Emit(OpCodes.Ret);
@@ -244,16 +236,16 @@
 
     private Constructor FindStorableConstructor(Type type) {
-      foreach (ConstructorInfo ci in type.GetConstructors(ALL_CONSTRUCTORS)) {
-        if (ci.GetCustomAttributes(typeof(StorableConstructorAttribute), false).Length > 0) {
-          if (ci.GetParameters().Length != 1 ||
-              ci.GetParameters()[0].ParameterType != typeof(bool))
-            throw new PersistenceException("StorableConstructor must have exactly one argument of type bool");
-          DynamicMethod dm = new DynamicMethod("", typeof(object), null, type, true);
-          ILGenerator ilgen = dm.GetILGenerator();
-          ilgen.Emit(OpCodes.Ldc_I4_1); // load true
-          ilgen.Emit(OpCodes.Newobj, ci);
-          ilgen.Emit(OpCodes.Ret);
-          return (Constructor)dm.CreateDelegate(typeof(Constructor));
-        }
+      foreach (var ci in type
+        .GetConstructors(ALL_CONSTRUCTORS)
+        .Where(ci => ci.GetCustomAttributes(typeof(StorableConstructorAttribute), false).Length > 0)) {
+        if (ci.GetParameters().Length != 1 ||
+            ci.GetParameters()[0].ParameterType != typeof(bool))
+          throw new PersistenceException("StorableConstructor must have exactly one argument of type bool");
+        var dm = new DynamicMethod("", typeof(object), null, type, true);
+        var ilgen = dm.GetILGenerator();
+        ilgen.Emit(OpCodes.Ldc_I4_1); // load true
+        ilgen.Emit(OpCodes.Newobj, ci);
+        ilgen.Emit(OpCodes.Ret);
+        return (Constructor)dm.CreateDelegate(typeof(Constructor));
       }
       return null;
@@ -262,6 +254,6 @@
     private void InvokeHook(HookType hookType, object obj) {
       if (obj == null)
-        throw new ArgumentNullException("Cannot invoke hooks on null");
-      foreach (StorableReflection.Hook hook in GetHooks(hookType, obj.GetType())) {
+        throw new ArgumentNullException("obj");
+      foreach (var hook in GetHooks(hookType, obj.GetType())) {
         hook(obj);
       }
Index: branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/Char2XmlFormatter.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/Char2XmlFormatter.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/Char2XmlFormatter.cs	(revision 11009)
@@ -20,4 +20,7 @@
 #endregion
 
+using System;
+using System.Text;
+using System.Text.RegularExpressions;
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
@@ -27,12 +30,24 @@
   internal sealed class Char2XmlSerializer : PrimitiveSerializerBase<char, XmlString> {
 
+    private static readonly Regex base64Regex = new Regex("<Base64>(.+)</Base64>");
+
+    private static bool IsSpecial(char c) {
+      return c <= 0x1F && c != 0x9 && c != 0xA && c != 0xD;
+    }
+
+    private static string ToBase64String(char c) {
+      return string.Format("<Base64>{0}</Base64>", Convert.ToBase64String(Encoding.ASCII.GetBytes(new[] {c})));
+    }
+
     public override XmlString Format(char c) {
-      return new XmlString(new string(c, 1));
+      return new XmlString(IsSpecial(c) ? ToBase64String(c) : new string(c, 1));
     }
 
     public override char Parse(XmlString x) {
-      if (x.Data.Length != 1)
-        throw new PersistenceException("Invalid character format, XML string length != 1");
-      return x.Data[0];
+      if (x.Data.Length <= 1) return x.Data[0];
+      var m = base64Regex.Match(x.Data);
+      if (m.Success)
+        return Encoding.ASCII.GetString(Convert.FromBase64String(m.Groups[1].Value))[0];
+      throw new PersistenceException("Invalid character format, XML string length != 1");
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlSerializer.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlSerializer.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlSerializer.cs	(revision 11009)
@@ -20,8 +20,8 @@
 #endregion
 
+using System;
 using System.Text;
 using System.Text.RegularExpressions;
 using HeuristicLab.Persistence.Core;
-
 
 namespace HeuristicLab.Persistence.Default.Xml.Primitive {
@@ -42,8 +42,18 @@
       sb.Append(s.Replace("]]>", "]]]]><![CDATA[>"));
       sb.Append("]]>");
-      return new XmlString(sb.ToString());
+      s = special.Replace(sb.ToString(), m => ToBase64Tag(m.Value));
+      return new XmlString(s);
     }
 
-    private static Regex re = new Regex(@"<!\[CDATA\[((?:[^]]|\](?!\]>))*)\]\]>", RegexOptions.Singleline);
+    private static readonly Regex re = new Regex(@"<!\[CDATA\[((?:[^]]|\](?!\]>))*)\]\]>|<Base64>([^<]*)</Base64>", RegexOptions.Singleline);
+    private static readonly Regex special = new Regex(@"[\x00-\x08\x0b\x0c\x0e-\x1f]+", RegexOptions.Singleline);
+
+    private static string ToBase64Tag(string s) {
+      return new StringBuilder()
+        .Append("]]><Base64>")
+        .Append(Convert.ToBase64String(Encoding.ASCII.GetBytes(s)))
+        .Append("</Base64><![CDATA[")
+        .ToString();
+    }
 
     /// <summary>
@@ -55,5 +65,9 @@
       StringBuilder sb = new StringBuilder();
       foreach (Match m in re.Matches(x.Data)) {
-        sb.Append(m.Groups[1]);
+        if (m.Groups[1].Success)
+          sb.Append(m.Groups[1].Value);
+        else if (m.Groups[2].Success) {
+          sb.Append(Encoding.ASCII.GetString(Convert.FromBase64String(m.Groups[2].Value)));
+        }
       }
       string result = sb.ToString();
Index: branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/System.Drawing/Font2XmlSerializer.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/System.Drawing/Font2XmlSerializer.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/System.Drawing/Font2XmlSerializer.cs	(revision 11009)
@@ -28,5 +28,5 @@
     public override XmlString Format(Font font) {
       return new XmlString(string.Format("{0};{1};{2};{3};{4};{5}",
-        font.FontFamily.Name,
+        GetFontFamilyName(font.FontFamily),
         Float2XmlSerializer.FormatG8(font.Size),
         font.Style,
@@ -39,5 +39,5 @@
       string[] tokens = fontData.Data.Split(';');
       return new Font(
-        tokens[0],
+        GetFontFamily(tokens[0]),
         Float2XmlSerializer.ParseG8(tokens[1]),
         (FontStyle)Enum.Parse(typeof(FontStyle), tokens[2]),
@@ -46,4 +46,23 @@
         bool.Parse(tokens[5]));
     }
+
+    public const string GENERIC_MONOSPACE_NAME = "_GenericMonospace";
+    public const string GENERIC_SANS_SERIF_NAME = "_GenericSansSerif";
+    public const string GENERIC_SERIF_NAME = "_GenericSerif";
+
+    public static FontFamily GetFontFamily(string name) {
+      if (name == GENERIC_MONOSPACE_NAME) return FontFamily.GenericMonospace;
+      if (name == GENERIC_SANS_SERIF_NAME) return FontFamily.GenericSansSerif;
+      if (name == GENERIC_SERIF_NAME) return FontFamily.GenericSerif;
+      return new FontFamily(name);
+    }
+
+    public static string GetFontFamilyName(FontFamily ff) {
+      if (ff.Equals(FontFamily.GenericMonospace)) return GENERIC_MONOSPACE_NAME;
+      if (ff.Equals(FontFamily.GenericSansSerif)) return GENERIC_SANS_SERIF_NAME;
+      if (ff.Equals(FontFamily.GenericSerif)) return GENERIC_SERIF_NAME;
+      return ff.Name;
+    }
+
   }
 }
