Changeset 1780 for trunk/sources/HeuristicLab.Persistence/3.3/Core

Timestamp:

05/11/09 16:09:29 (15 years ago)

Author:

epitzer

Message:

Store full version information with serialized data, only fall back to version invariant format if loading fails with full version. Also check, that loaded version is newer than requested version if possible. (#613)

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Core

Files:

• DeSerializer.cs (modified) (3 diffs)
• Serializer.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs

@@ -9 +9 @@
 namespace HeuristicLab.Persistence.Core {
 
+  public class TypeLoader {
+
+    public static Type Load(string typeNameString) {
+      Type type;
+      try {
+        type = Type.GetType(typeNameString, true);
+      } catch (Exception) {
+        Logger.Warn(String.Format(
+          "Cannot load type \"{0}\", falling back to loading with partial name", typeNameString));
+        try {
+          TypeName typeName = TypeNameParser.Parse(typeNameString);
+          Assembly a = Assembly.LoadWithPartialName(typeName.AssemblyName);
+          type = a.GetType(typeName.ToString(false, false), true);
+        } catch (Exception) {
+          throw new PersistenceException(String.Format(
+            "Could not load type \"{0}\"",
+            typeNameString));
+        }
+        try {
+          if (
+            TypeNameParser.Parse(type.AssemblyQualifiedName).IsOlderThan(
+            TypeNameParser.Parse(typeNameString)))
+            throw new PersistenceException(String.Format(
+              "Serialized type is newer than available type: serialized: {0}, loaded: {1}",
+              typeNameString,
+              type.AssemblyQualifiedName));
+        } catch (PersistenceException) {
+          throw;
+        } catch (Exception e) {
+          Logger.Warn(String.Format(
+            "Could not perform version check requested type was {0} while loaded type is {1}:",
+            typeNameString,
+            type.AssemblyQualifiedName),
+            e);
+        }
+      }
+      return type;
+    }
+
+  }
+
   public class Deserializer {
 
@@ -71 +112 @@
         var map = new Dictionary<Type, object>();
         foreach (var typeMapping in typeCache) {
-          Type type;
-          try {
-            type = Type.GetType(typeMapping.TypeName, true);
-          } catch (Exception) {
-            Logger.Error(String.Format(
-              "Cannot load type \"{0}\", falling back to loading with partial name", typeMapping.TypeName));
-            string[] typeNameParts = typeMapping.TypeName.Split(new[] { ',' });
-            try {
-              Assembly a = Assembly.LoadWithPartialName(typeNameParts[typeNameParts.Length - 1].Trim());
-              Array.Resize(ref typeNameParts, typeNameParts.Length - 1);
-              type = a.GetType(string.Join(",", typeNameParts), true);
-            } catch (Exception) {
-              throw new PersistenceException(String.Format(
-                "Could not load type \"{0}\"",
-                typeMapping.TypeName));
-            }
-          }
+          Type type = TypeLoader.Load(typeMapping.TypeName);
           typeIds.Add(typeMapping.Id, type);
-          Type serializerType = Type.GetType(typeMapping.Serializer, true);
+          Type serializerType = TypeLoader.Load(typeMapping.Serializer);
           map.Add(type, Activator.CreateInstance(serializerType, true));
         }
@@ -101 +126 @@
       }
     }
+
 
     public object Deserialize(IEnumerable<ISerializationToken> tokens) {

trunk/sources/HeuristicLab.Persistence/3.3/Core/Serializer.cs

@@ -40 +40 @@
           IFormatter f = configuration.GetFormatter(pair.Key);
           if (f != null) {
-            serializer = f.GetType().VersionInvariantName();
+            serializer = f.GetType().AssemblyQualifiedName;
           } else {
             IDecomposer d = configuration.GetDecomposer(pair.Key);
-            serializer = d.GetType().VersionInvariantName();
+            serializer = d.GetType().AssemblyQualifiedName;
           }
+          //result.Add(new TypeMapping(pair.Value, pair.Key.AssemblyQualifiedName, serializer));
           result.Add(new TypeMapping(pair.Value, pair.Key.VersionInvariantName(), serializer));
         }