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;
}
}
