public void GenericList() { var serializer = new Core.Serializer(new LoadedAssembliesGenericTypesProvider()); var value = new List <GenericBaseClass> { new GenericBaseClass(), new GenericBaseInheritedClass(), new GenericBaseInheritedInheritedClass() }; var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <List <GenericBaseClass> >(serialized); deserialized.Should().SatisfyRespectively ( first => { first.Should().BeOfType <GenericBaseClass>(); first.Field1.Should().Be(value[0].Field1); }, second => { var casted = second as GenericBaseInheritedClass; casted.Should().NotBeNull(); casted.Field3.Should().Be((value[1] as GenericBaseInheritedClass).Field3); }, third => { var casted = third as GenericBaseInheritedInheritedClass; casted.Should().NotBeNull(); casted.Field4.Should().Be((value[2] as GenericBaseInheritedInheritedClass).Field4); } ); AssertObject(value); }
public void Int(int value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <int>(serialized); deserialized.Should().Be(value); }
public void Bool(bool value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <bool>(serialized); deserialized.Should().Be(value); }
public void String(string value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <string>(serialized); deserialized.Should().Be(value); }
public void Char(char value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <char>(serialized); deserialized.Should().Be(value); }
public void Float(float value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <float>(serialized); deserialized.Should().Be(value); }
public void Byte(byte value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <byte>(serialized); deserialized.Should().Be(value); }
public void UShort(ushort value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <ushort>(serialized); deserialized.Should().Be(value); }
private static void AssertList <T> (List <T> value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <List <T> >(serialized); Assert.True(ListComparer(value, deserialized)); }
private static void AssertDictionary <T1, T2> (Dictionary <T1, T2> value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <Dictionary <T1, T2> >(serialized); Assert.True(DictionaryComparer(value, deserialized)); }
public void Enum(EnumData value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <EnumData>(serialized); deserialized.Should().Be(value); }
public void Guid(string GuidString) { var guid = System.Guid.Parse(GuidString); var serializer = new Core.Serializer(); var serialized = serializer.Serialize(guid); var deserialized = serializer.Deserialize <Guid>(serialized); deserialized.Should().Be(guid); }
private static void Main(string[] args) { var valueToSerialize = (ushort)12; var serializer = new Core.Serializer(); var serialized = serializer.Serialize(valueToSerialize); var deserialized = serializer.Deserialize <ushort>(serialized); Console.WriteLine(deserialized); //new ComplexObject().ThreeLevelObject(); }
private static void AssertObject <T> (T value) { var serializer = new Core.Serializer(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <T>(serialized); // Although this method can't 100% prove the deserialized value is equal to the original unserialized object, // the probability of a false positive is very low - according with the other tests -. var serializedDeserialized = serializer.Serialize(deserialized); serializedDeserialized.Should().Equal(serialized); }
private static void Serialize(Stream stream, Core.Serializer serializer, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); using (StreamWriter writer = new StreamWriter(new GZipStream(stream, CompressionMode.Compress))) { serializer.InterleaveTypeInformation = true; XmlGenerator generator = new XmlGenerator(); foreach (ISerializationToken token in serializer) { cancellationToken.ThrowIfCancellationRequested(); string line = generator.Format(token); writer.Write(line); } writer.Flush(); } }
public void PostDeserializationCast() { var serializer = new Core.Serializer(new LoadedAssembliesGenericTypesProvider()); var value = new GenericBaseInheritedInheritedClass(); var serialized = serializer.Serialize(value); var deserialized = serializer.Deserialize <GenericBaseClass>(serialized); var deserializedCastedAsGenericBaseInherited = deserialized as GenericBaseInheritedClass; var deserializedCastedAsGenericBaseInheritedInherited = deserialized as GenericBaseInheritedInheritedClass; deserializedCastedAsGenericBaseInherited.Should().NotBeNull(); deserializedCastedAsGenericBaseInheritedInherited.Should().NotBeNull(); deserializedCastedAsGenericBaseInherited.Field3.Should().Be(value.Field3); deserializedCastedAsGenericBaseInheritedInherited.Field4.Should().Be(value.Field4); AssertObject(value); }
/// <summary> /// Serializes the specified object into a stream. /// </summary> /// <param name="obj">The object.</param> /// <param name="stream">The stream.</param> /// <param name="config">The configuration.</param> /// <param name="includeAssemblies">if set to <c>true</c> include need assemblies.</param> /// <param name="compressionType">Type of compression, default is GZip.</param> public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) { try { Core.Serializer serializer = new Core.Serializer(obj, config); if (compressionType == CompressionType.Zip) { Serialize(obj, stream, config, includeAssemblies, CompressionLevel.Optimal, cancellationToken); } else { Serialize(stream, serializer, cancellationToken); } } catch (PersistenceException) { throw; } catch (Exception e) { throw new PersistenceException("Unexpected exception during Serialization.", e); } }
/// <summary> /// Serializes the specified object into a stream. /// </summary> /// <param name="obj">The object.</param> /// <param name="stream">The stream.</param> /// <param name="config">The configuration.</param> public static void Serialize(object obj, Stream stream, Configuration config) { try { using (StreamWriter writer = new StreamWriter(stream)) { Core.Serializer serializer = new Core.Serializer(obj, config); serializer.InterleaveTypeInformation = true; ReadableXmlGenerator generator = new ReadableXmlGenerator(); foreach (ISerializationToken token in serializer) { string line = generator.Format(token); writer.Write(line); } writer.Flush(); } } catch (PersistenceException) { throw; } catch (Exception e) { throw new PersistenceException("Unexpected exception during Serialization.", e); } }
private void ProfilePersistenceToMemory(string fileName) { var REPS = 5; var oldDeserStopwatch = new Stopwatch(); var oldSerStopwatch = new Stopwatch(); var newDeserStopwatch = new Stopwatch(); var newSerStopwatch = new Stopwatch(); long oldSize = 0, newSize = 0; var config = ConfigurationService.Instance.GetConfiguration(new XmlFormat()); int[] oldCollections = new int[3]; int[] newCollections = new int[3]; for (int i = 0; i < REPS; i++) { var original = XmlParser.Deserialize(fileName); object deserializedObject1 = null; object deserializedObject2 = null; byte[] buf; System.GC.Collect(); var collection0 = System.GC.CollectionCount(0); var collection1 = System.GC.CollectionCount(1); var collection2 = System.GC.CollectionCount(2); using (var s = new MemoryStream()) { oldSerStopwatch.Start(); // serialize manually so that the stream won't be closed var serializer = new Core.Serializer(original, config); serializer.InterleaveTypeInformation = true; using (StreamWriter writer = new StreamWriter(new GZipStream(s, CompressionMode.Compress))) { XmlGenerator generator = new XmlGenerator(); foreach (ISerializationToken token in serializer) { writer.Write(generator.Format(token)); } writer.Flush(); oldSize += s.Length; } oldSerStopwatch.Stop(); buf = s.GetBuffer(); } using (var s = new MemoryStream(buf)) { oldDeserStopwatch.Start(); deserializedObject1 = XmlParser.Deserialize(s); oldDeserStopwatch.Stop(); } System.GC.Collect(); oldCollections[0] += System.GC.CollectionCount(0) - collection0; oldCollections[1] += System.GC.CollectionCount(1) - collection1; oldCollections[2] += System.GC.CollectionCount(2) - collection2; collection0 = System.GC.CollectionCount(0); collection1 = System.GC.CollectionCount(1); collection2 = System.GC.CollectionCount(2); // Protobuf only uses Deflate using (var m = new MemoryStream()) { // using (var s = new GZipStream(m, CompressionMode.Compress)) { // same as old persistence using (var s = new DeflateStream(m, CompressionMode.Compress)) { // new format newSerStopwatch.Start(); (new ProtoBufSerializer()).Serialize(original, s, false); s.Flush(); newSerStopwatch.Stop(); newSize += m.Length; } buf = m.GetBuffer(); } using (var m = new MemoryStream(buf)) { // using (var s = new GZipStream(m, CompressionMode.Decompress)) { // same as old persistence using (var s = new DeflateStream(m, CompressionMode.Decompress)) { // new format newDeserStopwatch.Start(); deserializedObject2 = (new ProtoBufSerializer()).Deserialize(s); newDeserStopwatch.Stop(); } } //Assert.AreEqual(deserializedObject1.GetObjectGraphObjects().Count(), deserializedObject2.GetObjectGraphObjects().Count()); System.GC.Collect(); newCollections[0] += System.GC.CollectionCount(0) - collection0; newCollections[1] += System.GC.CollectionCount(1) - collection1; newCollections[2] += System.GC.CollectionCount(2) - collection2; } Console.WriteLine($"{fileName} " + $"{oldSize / (double)REPS} " + $"{newSize / (double)REPS} " + $"{oldSerStopwatch.ElapsedMilliseconds / (double)REPS} " + $"{newSerStopwatch.ElapsedMilliseconds / (double)REPS} " + $"{oldDeserStopwatch.ElapsedMilliseconds / (double)REPS} " + $"{newDeserStopwatch.ElapsedMilliseconds / (double)REPS} " + $"{oldCollections[0] / (double)REPS} " + $"{newCollections[0] / (double)REPS} " + $"{oldCollections[1] / (double)REPS} " + $"{newCollections[1] / (double)REPS} " + $"{oldCollections[2] / (double)REPS} " + $"{newCollections[2] / (double)REPS} " + $""); }
private static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, CompressionLevel compression, CancellationToken cancellationToken = default(CancellationToken)) { Core.Serializer serializer = new Core.Serializer(obj, config); Serialize(stream, includeAssemblies, compression, serializer, cancellationToken); }
private static void Serialize(Stream stream, bool includeAssemblies, CompressionLevel compression, Core.Serializer serializer, CancellationToken cancellationToken = default(CancellationToken)) { try { cancellationToken.ThrowIfCancellationRequested(); DateTime start = DateTime.Now; serializer.InterleaveTypeInformation = false; XmlGenerator generator = new XmlGenerator(); using (ZipArchive zipArchive = new ZipArchive(stream, ZipArchiveMode.Create)) { ZipArchiveEntry entry = zipArchive.CreateEntry("data.xml", compression); using (StreamWriter writer = new StreamWriter(entry.Open())) { foreach (ISerializationToken token in serializer) { cancellationToken.ThrowIfCancellationRequested(); string line = generator.Format(token); writer.Write(line); } } entry = zipArchive.CreateEntry("typecache.xml", compression); using (StreamWriter writer = new StreamWriter(entry.Open())) { foreach (string line in generator.Format(serializer.TypeCache)) { writer.Write(line); } } if (includeAssemblies) { foreach (string name in serializer.RequiredFiles) { cancellationToken.ThrowIfCancellationRequested(); Uri uri = new Uri(name); if (!uri.IsFile) { Logger.Warn("cannot read non-local files"); continue; } entry = zipArchive.CreateEntry(Path.GetFileName(uri.PathAndQuery), compression); using (BinaryWriter bw = new BinaryWriter(entry.Open())) { using (FileStream reader = File.OpenRead(uri.PathAndQuery)) { byte[] buffer = new byte[1024 * 1024]; while (true) { cancellationToken.ThrowIfCancellationRequested(); int bytesRead = reader.Read(buffer, 0, 1024 * 1024); if (bytesRead == 0) { break; } bw.Write(buffer, 0, bytesRead); } } } } } } Logger.Info(String.Format("serialization took {0} seconds with compression level {1}", (DateTime.Now - start).TotalSeconds, compression)); } catch (Exception) { Logger.Warn("Exception caught, no data has been serialized."); throw; } }