Changeset 12455


Ignore:
Timestamp:
06/16/15 13:43:03 (4 years ago)
Author:
ascheibe
Message:

#2368 added support in persistence for typecaches in streams

Location:
trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

    r12012 r12455  
    311311    }
    312312
     313    private static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies
     314   , CompressionLevel compression) {
     315      Serializer serializer = new Serializer(obj, config);
     316      Serialize(stream, includeAssemblies, compression, serializer);
     317    }
     318
     319    private static void Serialize(Stream stream, bool includeAssemblies, CompressionLevel compression, Serializer serializer) {
     320      try {
     321        DateTime start = DateTime.Now;
     322        serializer.InterleaveTypeInformation = false;
     323        XmlGenerator generator = new XmlGenerator();
     324        using (ZipArchive zipArchive = new ZipArchive(stream, ZipArchiveMode.Create)) {
     325          ZipArchiveEntry entry = zipArchive.CreateEntry("data.xml", compression);
     326          using (StreamWriter writer = new StreamWriter(entry.Open())) {
     327            foreach (ISerializationToken token in serializer) {
     328              string line = generator.Format(token);
     329              writer.Write(line);
     330            }
     331          }
     332          entry = zipArchive.CreateEntry("typecache.xml", compression);
     333          using (StreamWriter writer = new StreamWriter(entry.Open())) {
     334            foreach (string line in generator.Format(serializer.TypeCache)) {
     335              writer.Write(line);
     336            }
     337          }
     338          if (includeAssemblies) {
     339            foreach (string name in serializer.RequiredFiles) {
     340              Uri uri = new Uri(name);
     341              if (!uri.IsFile) {
     342                Logger.Warn("cannot read non-local files");
     343                continue;
     344              }
     345              entry = zipArchive.CreateEntry(Path.GetFileName(uri.PathAndQuery), compression);
     346              using (BinaryWriter bw = new BinaryWriter(entry.Open())) {
     347                using (FileStream reader = File.OpenRead(uri.PathAndQuery)) {
     348                  byte[] buffer = new byte[1024 * 1024];
     349                  while (true) {
     350                    int bytesRead = reader.Read(buffer, 0, 1024 * 1024);
     351                    if (bytesRead == 0)
     352                      break;
     353                    bw.Write(buffer, 0, bytesRead);
     354                  }
     355                }
     356              }
     357            }
     358          }
     359        }
     360        Logger.Info(String.Format("serialization took {0} seconds with compression level {1}",
     361          (DateTime.Now - start).TotalSeconds, compression));
     362      }
     363      catch (Exception) {
     364        Logger.Warn("Exception caught, no data has been serialized.");
     365        throw;
     366      }
     367    }
     368
    313369    /// <summary>
    314370    /// Serializes the specified object into a file.
     
    322378      try {
    323379        string tempfile = Path.GetTempFileName();
    324         DateTime start = DateTime.Now;
     380
    325381        using (FileStream stream = File.Create(tempfile)) {
    326           Serializer serializer = new Serializer(obj, config);
    327           serializer.InterleaveTypeInformation = false;
    328           XmlGenerator generator = new XmlGenerator();
    329           using (ZipArchive zipArchive = new ZipArchive(stream, ZipArchiveMode.Create)) {
    330             ZipArchiveEntry entry = zipArchive.CreateEntry("data.xml", compression);
    331             using (StreamWriter writer = new StreamWriter(entry.Open())) {
    332               foreach (ISerializationToken token in serializer) {
    333                 string line = generator.Format(token);
    334                 writer.Write(line);
    335               }
    336             }
    337             entry = zipArchive.CreateEntry("typecache.xml", compression);
    338             using (StreamWriter writer = new StreamWriter(entry.Open())) {
    339               foreach (string line in generator.Format(serializer.TypeCache)) {
    340                 writer.Write(line);
    341               }
    342             }
    343             if (includeAssemblies) {
    344               foreach (string name in serializer.RequiredFiles) {
    345                 Uri uri = new Uri(name);
    346                 if (!uri.IsFile) {
    347                   Logger.Warn("cannot read non-local files");
    348                   continue;
    349                 }
    350                 entry = zipArchive.CreateEntry(Path.GetFileName(uri.PathAndQuery), compression);
    351                 using (BinaryWriter bw = new BinaryWriter(entry.Open())) {
    352                   using (FileStream reader = File.OpenRead(uri.PathAndQuery)) {
    353                     byte[] buffer = new byte[1024 * 1024];
    354                     while (true) {
    355                       int bytesRead = reader.Read(buffer, 0, 1024 * 1024);
    356                       if (bytesRead == 0)
    357                         break;
    358                       bw.Write(buffer, 0, bytesRead);
    359                     }
    360                   }
    361                 }
    362               }
    363             }
    364           }
    365         }
    366         Logger.Info(String.Format("serialization took {0} seconds with compression level {1}",
    367           (DateTime.Now - start).TotalSeconds, compression));
     382          Serialize(obj, stream, config, includeAssemblies, compression);
     383        }
     384
    368385        File.Copy(tempfile, filename, true);
    369386        File.Delete(tempfile);
     
    381398    /// <param name="obj">The object.</param>
    382399    /// <param name="stream">The stream.</param>
    383     public static void Serialize(object obj, Stream stream) {
    384       Serialize(obj, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()));
     400    /// <param name="useZip">If true, uses zip for compression, otherwise gzip.</param>
     401    public static void Serialize(object obj, Stream stream, bool useZip = false) {
     402      Serialize(obj, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), useZip);
    385403    }
    386404
     
    392410    /// <param name="stream">The stream.</param>
    393411    /// <param name="config">The configuration.</param>
    394     public static void Serialize(object obj, Stream stream, Configuration config) {
    395       Serialize(obj, stream, config, false);
     412    /// <param name="useZip">If true, uses zip for compression, otherwise gzip.</param>
     413    public static void Serialize(object obj, Stream stream, Configuration config, bool useZip = false) {
     414      Serialize(obj, stream, config, false, useZip);
    396415    }
    397416
     
    403422    /// <param name="config">The configuration.</param>
    404423    /// <param name="includeAssemblies">if set to <c>true</c> include need assemblies.</param>
    405     public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies) {
     424    /// <param name="useZip">If true, uses zip for compression, otherwise gzip.</param>
     425    public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, bool useZip = false) {
    406426      try {
    407427        Serializer serializer = new Serializer(obj, config);
    408         Serialize(stream, serializer);
     428        if (useZip) {
     429          Serialize(obj, stream, config, includeAssemblies, CompressionLevel.Optimal);
     430        } else {
     431          Serialize(stream, serializer);
     432        }
    409433      }
    410434      catch (PersistenceException) {
     
    424448    /// <param name="includeAssemblies">if set to <c>true</c> include need assemblies.</param>
    425449    /// <param name="types">The list of all serialized types.</param>
    426     public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, out IEnumerable<Type> types) {
     450    /// <param name="useZip">If true, uses zip for compression, otherwise gzip.</param>
     451    public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, out IEnumerable<Type> types, bool useZip = false) {
    427452      try {
    428453        Serializer serializer = new Serializer(obj, config);
    429         Serialize(stream, serializer);
     454        if (useZip) {
     455          Serialize(stream, includeAssemblies, CompressionLevel.Optimal, serializer);
     456        } else {
     457          Serialize(stream, serializer);
     458        }
    430459        types = serializer.SerializedTypes;
    431460      }
  • trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlParser.cs

    r12012 r12455  
    218218
    219219    /// <summary>
    220     /// Deserializes an object from the specified stream.
     220    /// Deserializes an object from the specified stream using GZip compression.
    221221    /// </summary>
    222222    /// <param name="stream">The stream.</param>
    223223    /// <returns>A fresh object instance.</returns>
    224     public static object Deserialize(Stream stream) {
     224    public static object DeserializeWithGZip(Stream stream) {
    225225      try {
    226226        using (StreamReader reader = new StreamReader(new GZipStream(stream, CompressionMode.Decompress))) {
     
    239239
    240240    /// <summary>
     241    /// Deserializes an object from the specified stream using Zip compression.
     242    /// </summary>
     243    /// <param name="stream">The stream.</param>
     244    /// <returns>A fresh object instance.</returns>
     245    private static object DeserializeWithZip(Stream stream) {
     246      ZipArchive zipFile = new ZipArchive(stream);
     247      return Deserialize(zipFile);
     248    }
     249
     250    /// <summary>
    241251    /// Deserializes an object from the specified stream.
    242252    /// </summary>
    243253    /// <typeparam name="T">object type expected from the serialized stream</typeparam>
    244254    /// <param name="stream">The stream.</param>
     255    /// <param name="useZip">If true, uses zip for decompression, otherwise gzip.</param>
    245256    /// <returns>A fresh object instance.</returns>
    246     public static T Deserialize<T>(Stream stream) {
    247       return (T)Deserialize(stream);
     257    public static T Deserialize<T>(Stream stream, bool useZip = false) {
     258      return (T)Deserialize(stream, useZip);
     259    }
     260
     261    /// <summary>
     262    /// Deserializes an object from the specified stream.
     263    /// </summary>
     264    /// <param name="stream">The stream.</param>
     265    /// <param name="useZip">If true, uses zip for decompression, otherwise gzip.</param>
     266    /// <returns>A fresh object instance.</returns>
     267    public static object Deserialize(Stream stream, bool useZip = false) {
     268      if (useZip) {
     269        return DeserializeWithZip(stream);
     270      } else {
     271        return DeserializeWithGZip(stream);
     272      }
    248273    }
    249274
Note: See TracChangeset for help on using the changeset viewer.