public void DynamicFormatterClassTest()
{
var DynamicFormatter = new DynamicFormatter <ClassForTest>();
var testEntity = new ClassForTest();
var watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
var buffer = DynamicFormatter.Serialize(testEntity);
var testEintity = DynamicFormatter.Deserialize(buffer);
}
watch.Stop();
Debug.WriteLine($"DynamicSerialize result {watch.ElapsedMilliseconds} ms.");
}
public void DynamicFormatterNullableStructTest()
{
TestStruct?testEntity = new TestStruct()
{
B = 50,
G = 10,
R = 32
};
var DynamicFormatter = new DynamicFormatter <TestStruct?>();
var buffer = DynamicFormatter.Serialize(testEntity);
var resultEntity = DynamicFormatter.Deserialize(buffer);
Assert.AreEqual(testEntity, resultEntity);
}
public void DynamicFormatterClassWithNullableTest()
{
var entity = new ClassWithNullable();
entity.intNullable = 31;
entity.longNullable = 313;
var DynamicFormatter = new DynamicFormatter <ClassWithNullable>();
var buffer = DynamicFormatter.Serialize(entity);
var result = DynamicFormatter.Deserialize(buffer);
Assert.AreEqual(entity.intNullable, result.intNullable);
Assert.AreEqual(entity.longNullable, result.longNullable);
Assert.IsTrue(result.boolNulable == null);
}
public void DynamicFormatterStuctTest()
{
var DynamicFormatter = new DynamicFormatter <TestStruct>();
var testEntity = new TestStruct()
{
B = 50,
G = 99,
R = 1
};
var testEntityBytes = DynamicFormatter.Serialize(testEntity);
var testEintityResult = DynamicFormatter.Deserialize(testEntityBytes);
Assert.AreEqual(testEntity, testEintityResult);
}
public void DynamicFormatterDictionary()
{
var entity = new Dictionary <int, int>();
entity.Add(10, 9);
entity.Add(50, 12);
var DynamicFormatter = new DynamicFormatter <Dictionary <int, int> >();
var buffer = DynamicFormatter.Serialize(entity);
var result = DynamicFormatter.Deserialize(buffer);
foreach (var keyValue in entity)
{
Assert.AreEqual(keyValue.Value, result[keyValue.Key]);
}
}
public void AdebugTest()
{
var entity = new StrongStructure();
var serializer = new DynamicFormatter <StrongStructure>();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 50; i++)
{
var buffer = serializer.Serialize(entity);
var result = serializer.Deserialize(buffer);
}
watch.Stop();
long ms = watch.ElapsedMilliseconds;
}
public void TestPerfomenceStrongTypeWithMsgPack()
{
var entity = new StrongStructure();
var serializer = new DynamicFormatter <StrongStructure>();
{
var buffer = serializer.Serialize(entity);
var result = serializer.Deserialize(buffer);
}
var watch = Stopwatch.StartNew();
for (int i = 0; i < 1000; i++)
{
var buffer = serializer.Serialize(entity);
var result = serializer.Deserialize(buffer);
}
watch.Stop();
long ms = watch.ElapsedMilliseconds;
{
var bin = MessagePackSerializer.Serialize(entity);
// Okay to deserialize immutable obejct
var point = MessagePackSerializer.Deserialize <StrongStructure>(bin);
}
var msgPackWatch = Stopwatch.StartNew();
for (int i = 0; i < 1000; i++)
{
var bin = MessagePackSerializer.Serialize(entity);
// Okay to deserialize immutable obejct
var point = MessagePackSerializer.Deserialize <StrongStructure>(bin);
}
msgPackWatch.Stop();
var message = $"StrongTypeFormatter {watch.ElapsedMilliseconds} ms\r\nMessagePackSerializer {msgPackWatch.ElapsedMilliseconds} ms";
Assert.IsTrue(watch.ElapsedTicks < msgPackWatch.ElapsedTicks, message);
TestContext.WriteLine(message);
}
public void DynamicFormatterGenericInt()
{
var entity = new int[]
{
10,
20,
30
}.ToList();
var DynamicFormatter = new DynamicFormatter <List <int> >();
var buffer = DynamicFormatter.Serialize(entity);
var result = DynamicFormatter.Deserialize(buffer);
for (int i = 0; i < entity.Count; i++)
{
Assert.AreEqual(result[i], entity[i]);
}
}
public void DynamicFormatterDateTimeInClass()
{
var firstDate = DateTime.Now;
var secondDate = DateTime.Now.AddHours(1);
var DynamicFormatter = new DynamicFormatter <ClassWithDateTime>();
var testEntity = new ClassWithDateTime()
{
FirstDate = firstDate,
OtherDate = secondDate
};
var buffer = DynamicFormatter.Serialize(testEntity);
var resultTime = DynamicFormatter.Deserialize(buffer);
Assert.AreEqual(testEntity.FirstDate, resultTime.FirstDate);
Assert.AreEqual(testEntity.OtherDate, resultTime.OtherDate);
}
public void DynamicFormatterGenericClass()
{
var entity = new ClassWithNullable[]
{
new ClassWithNullable(),
new ClassWithNullable(),
new ClassWithNullable()
}.ToList();
var DynamicFormatter = new DynamicFormatter <List <ClassWithNullable> >();
var buffer = DynamicFormatter.Serialize(entity);
var result = DynamicFormatter.Deserialize(buffer);
for (int i = 0; i < entity.Count; i++)
{
Assert.AreEqual(result[i].longNullable, entity[i].longNullable);
}
}
protected override void OnBindingContextChanged()
{
base.OnBindingContextChanged();
if (Preferences is null)
{
return;
}
var contract = App.ViewModel.Contract ?? new Workflow();
var item = BindingContext as Contract;
contractTitle.Text = $"{contract.DisplayName} Contract {item?.Id}";
if (item != null)
{
var dynamicText = DynamicFormatter.GetString(contract, item, false, Preferences);
dynamicContent.FormattedText = dynamicText;
}
}
public void TestPerfomenceStrongTypeWithProtoBuf()
{
var entity = new StrongStructure();
var serializer = new DynamicFormatter <StrongStructure>();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 1000; i++)
{
var buffer = serializer.Serialize(entity);
serializer.Deserialize(buffer);
}
watch.Stop();
long ms = watch.ElapsedMilliseconds;
var protoBuf = Stopwatch.StartNew();
{
var buffer = ProtoBufHelper.ProtoSerialize(entity);
var obj = ProtoBufHelper.ProtoDeserialize <StrongStructure>(buffer);
}
for (int i = 0; i < 1000; i++)
{
var buffer = ProtoBufHelper.ProtoSerialize(entity);
var obj = ProtoBufHelper.ProtoDeserialize <StrongStructure>(buffer);
}
protoBuf.Stop();
var message = $"StrongTypeFormatter {watch.ElapsedMilliseconds} ms\r\nprotoBuf {protoBuf.ElapsedMilliseconds} ms";
Assert.IsTrue(watch.ElapsedTicks < protoBuf.ElapsedTicks,
message);
TestContext.WriteLine(message);
}
public void Setup()
{
var ceras = new CerasSerializer();
var parent1 = new Person
{
Age = -901,
FirstName = "Parent 1",
LastName = "abc",
Sex = Sex.Male,
};
var parent2 = new Person
{
Age = 7881964,
FirstName = "Parent 2",
LastName = "xyz",
Sex = Sex.Female,
};
_person = new Person
{
Age = 5,
FirstName = "Riki",
LastName = "Example Person Object",
Sex = Sex.Unknown,
Parent1 = parent1,
Parent2 = parent2,
};
var meta = ceras.GetTypeMetaData(typeof(Person));
var schema = meta.PrimarySchema;
_serializer1 = DynamicFormatter <Person> .GenerateSerializer(ceras, schema, false, false).Compile();
//_serializer2 = DynamicFormatter<Person>.GenerateSerializer2(ceras, schema, false, false);
}
void ActivateSchema(Schema schema)
{
// What schema changes are relevant to us?
// - Schema of own type
// - Schema of value-types inside us (dispatches for ref types are handled by RefFormatter anyway)
// For now we only adapt to change to the current type schema.
// Do we have serializers prepared for this schema already?
// Important sanity check, if this happens the user should definitely know about it!
if (_deserializationDepth > 0)
{
if (schema.Type.IsValueType)
{
throw new InvalidOperationException("Schema of a value-type has changed while an object-type is being deserialized. This is feature is WIP, check out GitHub for more information.");
}
}
// Use already compiled serializers
if (_generatedSerializerPairs.TryGetValue(schema, out var pair))
{
_serializer = pair.Serializer;
_deserializer = pair.Deserializer;
_currentSchema = schema;
return;
}
// No members?
if (schema.Members.Count == 0)
{
_serializer = (ref byte[] buffer, ref int offset, T value) => { };
_deserializer = (byte[] buffer, ref int offset, ref T value) => { };
return;
}
// Generate
if (schema.IsPrimary)
{
_serializer = DynamicFormatter <T> .GenerateSerializer(_ceras, schema, true).Compile();
_deserializer = DynamicFormatter <T> .GenerateDeserializer(_ceras, schema, true).Compile();
}
else
{
// Different Schema -> generate no serializer!
// Writing data in some old format is not supported (yet, maybe in the future).
// In theory we could do it. But it's not implemented because there would have to be some way for the user to specify what Schema to use.
// And we get into all sorts of troubles with type-conversion (not implemented yet, but it will probably arrive earlier than this...)
// This also protects us against bugs!
_serializer = ErrorSerializer;
_deserializer = DynamicFormatter <T> .GenerateDeserializer(_ceras, schema, true).Compile();
}
_currentSchema = schema;
_generatedSerializerPairs.Add(schema, new SerializerPair(_serializer, _deserializer));
}
public static void SerializeTest <T>(T entity, int iterationCount)
{
Console.WriteLine();
long serilizationResult = 0;
long desirilizationResult = 0;
int objectSize = 0;
var watch = new Stopwatch();
#region dynamicFormatter
var dynamicFormatter = new DynamicFormatter <T>();
byte[] dynamicBytes = null;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
dynamicBytes = dynamicFormatter.Serialize(entity);
}
watch.Stop();
objectSize = dynamicBytes.Length;
serilizationResult = watch.ElapsedMilliseconds;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
dynamicFormatter.Deserialize(dynamicBytes);
}
watch.Stop();
desirilizationResult = watch.ElapsedMilliseconds;
Console.WriteLine
($"dynamicFormatter deserialize reuslt for {entity.GetType().Name} and {iterationCount} iterations");
Console.WriteLine($"Serilization: {serilizationResult}ms");
Console.WriteLine($"Desirilization: {desirilizationResult}ms");
Console.WriteLine($"Total: {serilizationResult + desirilizationResult}ms");
Console.WriteLine($"Size: {objectSize} bytes.");
#endregion dynamicFormatter
Console.WriteLine();
#region json
try
{
watch = Stopwatch.StartNew();
string json = string.Empty;
for (int i = 0; i < iterationCount; i++)
{
json = JsonConvert.SerializeObject(entity);
}
watch.Stop();
serilizationResult = watch.ElapsedMilliseconds;
objectSize = Encoding.Default.GetBytes(json).Length;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
var obj = JsonConvert.DeserializeObject <T>(json);
}
watch.Stop();
desirilizationResult = watch.ElapsedMilliseconds;
Console.WriteLine
($"JsonConvert reuslt for {entity.GetType().Name} and {iterationCount} iterations");
Console.WriteLine($"Serilization: {serilizationResult}ms");
Console.WriteLine($"Desirilization: {desirilizationResult}ms");
Console.WriteLine($"Total: {serilizationResult + desirilizationResult}ms");
Console.WriteLine($"Size: {objectSize} bytes.");
}
catch (Exception ex)
{
Console.WriteLine($"Json not supported");
}
#endregion json
Console.WriteLine();
#region Binary
BinaryFormatter formatter = new BinaryFormatter();
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
using (var mStream = new MemoryStream())
{
formatter.Serialize(mStream, entity);
}
}
watch.Stop();
serilizationResult = watch.ElapsedMilliseconds;
byte[] binaryBytes = null;
{
using (var mStream = new MemoryStream())
{
formatter.Serialize(mStream, entity);
binaryBytes = mStream.ToArray();
}
}
objectSize = binaryBytes.Length;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
using (var mStream = new MemoryStream(binaryBytes))
{
object obj = formatter.Deserialize(mStream);
}
}
watch.Stop();
desirilizationResult = watch.ElapsedMilliseconds;
Console.WriteLine
($"BinaryFormatter reuslt for {entity.GetType().Name} and {iterationCount} iterations");
Console.WriteLine($"Serilization: {serilizationResult}ms");
Console.WriteLine($"Desirilization: {desirilizationResult}ms");
Console.WriteLine($"Total: {serilizationResult + desirilizationResult}ms");
Console.WriteLine($"Size: {objectSize} bytes.");
#endregion Binary
Console.WriteLine();
#region ZeroFormatterSerializer
try
{
byte[] zeroSerializeBytes = null;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
zeroSerializeBytes = ZeroFormatterSerializer.Serialize(entity);
}
watch.Stop();
objectSize = zeroSerializeBytes.Length;
serilizationResult = watch.ElapsedMilliseconds;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
T obj = ZeroFormatterSerializer.Deserialize <T>(zeroSerializeBytes);
}
watch.Stop();
desirilizationResult = watch.ElapsedMilliseconds;
Console.WriteLine
($"ZeroFormatterSerializer reuslt for {entity.GetType().Name} and {iterationCount} iterations");
Console.WriteLine($"Serilization: {serilizationResult}ms");
Console.WriteLine($"Desirilization: {desirilizationResult}ms");
Console.WriteLine($"Total: {serilizationResult + desirilizationResult}ms");
Console.WriteLine($"Size: {objectSize} bytes.");
}
catch (Exception ex)
{
Console.WriteLine($"ZeroFormatter not supported this type");
}
#endregion ZeroFormatterSerializer
Console.WriteLine();
#region ProtoBuf
try
{
byte[] zeroSerializeBytes = null;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
zeroSerializeBytes = ProtoBufHelper.ProtoSerialize <T>(entity);
}
watch.Stop();
serilizationResult = watch.ElapsedMilliseconds;
objectSize = zeroSerializeBytes.Length;
watch = Stopwatch.StartNew();
for (int i = 0; i < iterationCount; i++)
{
T obj = ProtoBufHelper.ProtoDeserialize <T>(zeroSerializeBytes);
}
watch.Stop();
desirilizationResult = watch.ElapsedMilliseconds;
Console.WriteLine
($"ProtoBuf reuslt for {entity.GetType().Name} and {iterationCount} iterations");
Console.WriteLine($"Serilization: {serilizationResult}ms");
Console.WriteLine($"Desirilization: {desirilizationResult}ms");
Console.WriteLine($"Total: {serilizationResult + desirilizationResult}ms");
Console.WriteLine($"Size: {objectSize} bytes.");
}
catch (Exception ex)
{
Console.WriteLine($"ProtoBuf not supported this type");
}
#endregion ProtoBuf
}
