public void ProtoBufSerializer_Serialize_GivenNullInput_ShouldReturnNull()
{
var protoBufSerializer = new ProtoBufSerializer();
var result = protoBufSerializer.Serialize<object>(null);
Assert.IsNull(result);
}
public void TestProtoBufSerializerSerialize()
{
// Arrange
ProtoBufSerializerTestEntity entity = new ProtoBufSerializerTestEntity
{
PartitionKey = "KE",
RowKey = "Hello",
Name = "Kevin",
Number = 5
};
ProtoBufSerializer serializer = new ProtoBufSerializer();
// Act
byte[] b = serializer.Serialize(entity);
// Assert
Assert.AreEqual(9, b.Length);
Assert.AreEqual(10, b[0]);
Assert.AreEqual(5, b[1]);
Assert.AreEqual(75, b[2]);
Assert.AreEqual(101, b[3]);
Assert.AreEqual(118, b[4]);
Assert.AreEqual(105, b[5]);
Assert.AreEqual(110, b[6]);
Assert.AreEqual(16, b[7]);
Assert.AreEqual(5, b[8]);
}
public void ProtoBufSerializer_Serialize_GivenValidReferenceTypeInput_ShouldReturnBytes()
{
var protoBufSerializer = new ProtoBufSerializer();
var input = "test";
var result = protoBufSerializer.Serialize(input);
Assert.IsNotNull(result);
Assert.IsTrue(result.Length > 0);
}
public void ProtoBufSerializer_Deserialize_GivenValidReferenceType_ShouldReturnReferenceType()
{
var protoBufSerializer = new ProtoBufSerializer();
var input = "test";
var serialized = protoBufSerializer.Serialize(input);
var deserialized = protoBufSerializer.Deserialize<string>(serialized);
Assert.IsNotNull(deserialized);
Assert.AreEqual("test", deserialized);
}
public void ProtoBufSerializer_Deserialize_GivenValidValueType_ShouldReturnValueType()
{
var protoBufSerializer = new ProtoBufSerializer();
var input = 123;
var serialized = protoBufSerializer.Serialize(input);
var deserialized = protoBufSerializer.Deserialize<int>(serialized);
Assert.IsNotNull(deserialized);
Assert.AreEqual(123, deserialized);
}
public void Serialize_NullObject_ThrowsNullArgument()
{
var sut = new ProtoBufSerializer(new ProtoBufOptions());
Assert.Throws <ArgumentNullException>(() => sut.Serialize((object)null));
}
static void Main(string[] args)
{
Console.WriteLine($"Begin");
Console.WriteLine();
byte[] data;
ValueDemo model;
byte[] data1;
MemoryStream ms;
ProtoWriter writestate;
var typeModel = RuntimeTypeModel.Create();
// Bool
ms = new MemoryStream();
writestate = ProtoBuf.ProtoWriter.Create(ms, typeModel);
ProtoWriter.WriteFieldHeader(3, WireType.Variant, writestate);
ProtoWriter.WriteBoolean(true, writestate);
writestate.Close();
ms.Position = 0;
data = ms.ToArray();
model = new ValueDemo {
Success = true
};
data1 = ProtoBufSerializer.Serialize(model);
ms.Close();
ms = null;
Print("bool");
// Int32
ms = new MemoryStream();
writestate = ProtoBuf.ProtoWriter.Create(ms, typeModel);
ProtoWriter.WriteFieldHeader(5, WireType.Variant, writestate);
ProtoWriter.WriteInt32(500, writestate);
writestate.Close();
ms.Position = 0;
data = ms.ToArray();
model = new ValueDemo {
Value = 500
};
data1 = ProtoBufSerializer.Serialize(model);
ms.Close();
ms = null;
Print("int32");
// Uint32
ms = new MemoryStream();
writestate = ProtoBuf.ProtoWriter.Create(ms, typeModel);
ProtoWriter.WriteFieldHeader(4, WireType.Variant, writestate);
ProtoWriter.WriteUInt32(UInt32.MaxValue, writestate);
writestate.Close();
ms.Position = 0;
data = ms.ToArray();
model = new ValueDemo {
Values = UInt32.MaxValue
};
data1 = ProtoBufSerializer.Serialize(model);
ms.Close();
ms = null;
Print("uint32");
Console.WriteLine();
Console.WriteLine($"End");
// Int32
void Print(string s)
{
Console.WriteLine($"{s} - wri: {BitConverter.ToString(data)}");
Console.WriteLine($"{s} - ser: {BitConverter.ToString(data1)}");
}
}
public void Nullable_Int16_should_be_serializable_deserialiazble()
{
Int16?value = 5;
var stream = ProtoBufSerializer.Serialize(value);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <Int16?>(stream).Should().Be(value);
value = Int16.MaxValue;
stream = ProtoBufSerializer.Serialize(value);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <Int16?>(stream).Should().Be(value);
value = Int16.MinValue;
stream = ProtoBufSerializer.Serialize(value);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <Int16?>(stream).Should().Be(value);
value = null;
stream = ProtoBufSerializer.Serialize(value);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <Int16?>(stream).Should().Be(value);
}
public void Int16_should_be_serializable_deserialiazble()
{
var stream = ProtoBufSerializer.Serialize(42);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <int>(stream).Should().Be(42);
stream = ProtoBufSerializer.Serialize(Int16.MaxValue);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <int>(stream).Should().Be(Int16.MaxValue);
stream = ProtoBufSerializer.Serialize(Int16.MinValue);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <int>(stream).Should().Be(Int16.MinValue);
stream = ProtoBufSerializer.Serialize(default(Int32));
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <int>(stream).Should().Be(default(Int32));
stream = ProtoBufSerializer.Serialize(-42);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <int>(stream).Should().Be(-42);
}
static void Main(string[] args)
{
var count = 100000;
var rnd = new Random((int)DateTime.UtcNow.Ticks & 0xFF);
Console.WriteLine("Generating {0} arrays of data...", count);
var arrays = new List <int[]>();
for (int i = 0; i < count; i++)
{
var elements = rnd.Next(1, 100);
var array = new int[elements];
for (int j = 0; j < elements; j++)
{
array[j] = rnd.Next();
}
arrays.Add(array);
}
Console.WriteLine("Test data generated.");
var stopWatch = new Stopwatch();
Console.WriteLine("Testing BinarySerializer...");
var binarySerializer = new BinarySerializer();
var binarySerialized = new List <byte[]>();
var binaryDeserialized = new List <int[]>();
stopWatch.Reset();
stopWatch.Start();
foreach (var array in arrays)
{
binarySerialized.Add(binarySerializer.Serialize(array));
}
stopWatch.Stop();
Console.WriteLine("BinaryFormatter: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);
stopWatch.Reset();
stopWatch.Start();
foreach (var serialized in binarySerialized)
{
binaryDeserialized.Add(binarySerializer.Deserialize <int[]>(serialized));
}
stopWatch.Stop();
Console.WriteLine("BinaryFormatter: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);
Console.WriteLine();
Console.WriteLine("Testing ProtoBuf serializer...");
var protobufSerializer = new ProtoBufSerializer();
var protobufSerialized = new List <byte[]>();
var protobufDeserialized = new List <int[]>();
stopWatch.Reset();
stopWatch.Start();
foreach (var array in arrays)
{
protobufSerialized.Add(protobufSerializer.Serialize(array));
}
stopWatch.Stop();
Console.WriteLine("ProtoBuf: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);
stopWatch.Reset();
stopWatch.Start();
foreach (var serialized in protobufSerialized)
{
protobufDeserialized.Add(protobufSerializer.Deserialize <int[]>(serialized));
}
stopWatch.Stop();
Console.WriteLine("ProtoBuf: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);
Console.WriteLine();
Console.WriteLine("Testing NetSerializer serializer...");
var netSerializerSerialized = new List <byte[]>();
var netSerializerDeserialized = new List <int[]>();
stopWatch.Reset();
stopWatch.Start();
var netSerializerSerializer = new NS();
foreach (var array in arrays)
{
netSerializerSerialized.Add(netSerializerSerializer.Serialize(array));
}
stopWatch.Stop();
Console.WriteLine("NetSerializer: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);
stopWatch.Reset();
stopWatch.Start();
foreach (var serialized in netSerializerSerialized)
{
netSerializerDeserialized.Add(netSerializerSerializer.Deserialize <int[]>(serialized));
}
stopWatch.Stop();
Console.WriteLine("NetSerializer: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);
Console.WriteLine("Press any key to end.");
Console.ReadKey();
}
protected override void SaveContent(IStorableContent content, string filename, bool compressed, CancellationToken cancellationToken)
{
var ser = new ProtoBufSerializer();
ser.Serialize(content, filename, cancellationToken);
}
// 序列化到一个别的Stream中
static void Sample2(Stream stream, SampleClass c)
{
ProtoBufSerializer.Serialize(stream, c);
}
// 使用MemoryStream序列化
static void Sample1(SampleClass c)
{
Stream stream = ProtoBufSerializer.Serialize <SampleClass>(c);
SampleClass sampleclass = ProtoBufSerializer.Deserialize <SampleClass>(stream);
}
private void CompareSerializers <T>(T obj, int runs)
{
//warm-up
#if NETFULL || NETCOREAPP3_1
jilserializer.SerializeToString(obj);
using (MemoryStream mem = new MemoryStream())
{
binaryserializer.Serialize(obj, mem);
}
using (MemoryStream mem = new MemoryStream())
{
datacontractserializer.Serialize(obj, mem);
}
#endif
#if NETFULL
using (MemoryStream mem = new MemoryStream())
{
soapserializer.Serialize(obj, mem);
}
#endif
var netserializer = SerializerFactory.Get("NET");
using (MemoryStream mem = new MemoryStream())
{
netserializer.Serialize(obj, mem);
}
jsonnetserializer.SerializeToString(obj);
textjsonserializer.SerializeToString(obj);
using (MemoryStream mem = new MemoryStream())
{
protobufserializer.Serialize(obj, mem);
}
xmlserializer.SerializeToString(obj);
var keys = serializer.Keys.ToList();
#if NETFULL || NETCOREAPP3_1
serializer["Jil"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["Jil"].Score = Helper.AverageRuntime(() =>
{
jilserializer.SerializeToString(obj);
}, runs);
};
serializer["Binary"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["Binary"].Score = Helper.AverageRuntime(() =>
{
using (MemoryStream mem = new MemoryStream())
{
binaryserializer.Serialize(obj, mem);
}
}, runs);
};
serializer["DataContract"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["DataContract"].Score = Helper.AverageRuntime(() =>
{
using (MemoryStream mem = new MemoryStream())
{
datacontractserializer.Serialize(obj, mem);
}
}, runs);
};
#endif
#if NETFULL
serializer["Soap"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["Soap"].Score = Helper.AverageRuntime(() =>
{
using (MemoryStream mem = new MemoryStream())
{
soapserializer.Serialize(obj, mem);
}
}, runs);
};
#endif
serializer["NET"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["NET"].Score = Helper.AverageRuntime(() =>
{
using (MemoryStream mem = new MemoryStream())
{
netserializer.Serialize(obj, mem);
}
}, runs);
};
serializer["Json"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["Json"].Score = Helper.AverageRuntime(() =>
{
jsonnetserializer.SerializeToString(obj);
}, runs);
};
serializer["TextJson"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["TextJson"].Score = Helper.AverageRuntime(() =>
{
textjsonserializer.SerializeToString(obj);
}, runs);
};
serializer["Xml"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["Xml"].Score = Helper.AverageRuntime(() =>
{
xmlserializer.SerializeToString(obj);
}, runs);
};
serializer["Protobuf"].Act = () =>
{
GC.Collect(2, GCCollectionMode.Forced, blocking: true);
serializer["Protobuf"].Score = Helper.AverageRuntime(() =>
{
using (MemoryStream mem = new MemoryStream())
{
protobufserializer.Serialize(obj, mem);
}
}, runs);
};
keys.ForEach(k =>
{
serializer[k].Act();
});
}
public static byte[] Serialize(object obj)
{
var ser = new ProtoBufSerializer();
return(ser.Serialize(obj));
}
public void String_should_be_serializable_deserialiazble()
{
var str = "test";
var stream = ProtoBufSerializer.Serialize(str);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <string>(stream).Should().Be(str);
str = "";
stream = ProtoBufSerializer.Serialize(str);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <string>(stream).Should().Be(str);
str = null;
stream = ProtoBufSerializer.Serialize(str);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize <string>(stream).Should().Be(str);
}
