private void DeserializeEnum(DeserializationStream stream, ref object propertyValue)
{
Type type = stream.ReadType();
var converter = new EnumConverter();
propertyValue = converter.DeserializeInto(stream, type);
}
public void ByteArrayWithLengthPrefixCanBeReaded()
{
// Arrange
var data = Encoding.UTF8.GetBytes("hello world");
var size = BitConverter.GetBytes(data.Length);
var finalData = new List <byte>();
foreach (byte b in size)
{
finalData.Add(b);
}
foreach (byte b in data)
{
finalData.Add(b);
}
// Act
var stream = new DeserializationStream(finalData.ToArray());
var result = stream.ReadBytesWithSizePrefix();
// Assert
result.Should().Equal(data);
stream.Offset.Should().Be(finalData.Count);
}
public T Deserialize <T>(byte[] bytes)
{
var stream = new DeserializationStream(bytes);
SerializedType deserializedType = stream.ReadSerializedType();
if (deserializedType == SerializedType.Null)
{
return(default);
public Enum DeserializeInto(DeserializationStream stream, Type type)
{
byte[] enumData = stream.ReadBytesWithSizePrefix();
BinaryConverter converter = new BinaryConverter();
var underlyingValue = converter.Deserialize <object>(enumData);
return((Enum)Enum.ToObject(type, underlyingValue));
}
public void Ends_WhenItsEmpty()
{
// Arrange
var data = new byte[0];
// Act
var stream = new DeserializationStream(data);
// Assert
stream.HasEnded.Should().BeTrue();
}
public void NotEnds_WhenOffsetIsSmallerThanData()
{
// Arrange
var data = new byte[64];
// Act
var stream = new DeserializationStream(data, data.Length - 1);
// Assert
stream.HasEnded.Should().BeFalse();
}
public void Ends_WhenOffsetIsEqualStreamLength()
{
// Arrange
var data = new byte[64];
// Act
var stream = new DeserializationStream(data, data.Length);
// Assert
stream.HasEnded.Should().BeTrue();
}
private void DeserializeObject <T>(DeserializationStream stream, ref T instance)
{
stream.ReadType();
foreach (var field in instance.GetType().GetFieldsAccessibleForSerializer())
{
DeserializeField(field, ref instance, stream);
if (stream.HasEnded)
{
return;
}
}
}
public void ByteCanBeReaded(byte value)
{
// Arrange
var data = BitConverter.GetBytes(value);
// Act
var stream = new DeserializationStream(data);
var result = stream.ReadByte();
// Assert
result.Should().Be(value);
stream.Offset.Should().Be(sizeof(byte));
}
public void ByteArrayWithoutLengthPrefixCanBeReaded()
{
// Arrange
var data = Encoding.UTF8.GetBytes("hello world");
// Act
var stream = new DeserializationStream(data);
var result = stream.ReadBytes(data.Length);
// Assert
result.Should().Equal(data);
stream.Offset.Should().Be(data.Length);
}
public void OffsetCanBeChanged()
{
// Arrange
var data = new byte[64];
const int newIndex = 2;
// Act
var stream = new DeserializationStream(data);
stream.SetOffset(newIndex);
// Assert
stream.Offset.Should().Be(newIndex);
}
protected override object DeserializeInternal(DeserializationStream stream, Type sourceType)
{
BinaryConverter converter = new BinaryConverter();
byte[] keyData = stream.ReadBytesWithSizePrefix();
var deserializedKey = converter.Deserialize <object>(keyData);
byte[] valueData = stream.ReadBytesWithSizePrefix();
var deserializedValue = converter.Deserialize <object>(valueData);
var newKeyValuePair = Activator.CreateInstance(sourceType, deserializedKey, deserializedValue);
return(newKeyValuePair);
}
protected override object DeserializeInternal(DeserializationStream stream, Type sourceType)
{
var instance = Activator.CreateInstance(sourceType);
foreach (var field in sourceType.GetFieldsAccessibleForSerializer())
{
DeserializeField(field, ref instance, stream);
if (stream.HasEnded)
{
break;
}
}
return(instance);
}
public void TypeCanReaded(string typeName, Type expectedType)
{
// arrange
byte[] typeInfo = Encoding.UTF8.GetBytes(typeName);
byte[] sizeBytes = BitConverter.GetBytes(typeInfo.Length);
byte[] data = new byte[sizeBytes.Length + typeInfo.Length];
Array.Copy(sizeBytes, 0, data, 0, sizeBytes.Length);
Array.Copy(typeInfo, 0, data, sizeBytes.Length, typeInfo.Length);
// Act
var stream = new DeserializationStream(data);
Type type = stream.ReadType();
// Assert
type.Should().Be(expectedType);
stream.Offset.Should().Be(data.Length);
}
protected override Guid DeserializeInternal(DeserializationStream stream, Type sourceType)
{
byte[] guidData = stream.ReadBytesWithSizePrefix();
return(new Guid(guidData));
}
protected override Enum DeserializeInternal(DeserializationStream stream, Type sourceType)
{
Enum result = DeserializeInto(stream, sourceType);
return(result);
}
protected override decimal DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(stream.ReadDecimal());
}
protected override byte[] DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(stream.ReadBytesWithSizePrefix());
}
protected override float DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(stream.ReadFloat());
}
protected override DateTime DeserializeInternal(DeserializationStream stream, Type sourceType)
{
long ticks = stream.ReadLong();
return(DateTime.FromBinary(ticks));
}
public override object Deserialize(DeserializationStream stream, Type type)
{
return(DeserializeInternal(stream, type));
}
protected override ulong DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(stream.ReadULong());
}
protected override BigInteger DeserializeInternal(DeserializationStream stream, Type sourceType)
{
byte[] bigIntegerData = stream.ReadBytesWithSizePrefix();
return(new BigInteger(bigIntegerData));
}
protected override byte DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(stream.ReadByte());
}
protected override TimeSpan DeserializeInternal(DeserializationStream stream, Type sourceType)
{
long ticks = stream.ReadLong();
return(TimeSpan.FromTicks(ticks));
}
public override object Deserialize(DeserializationStream stream)
{
return(Deserialize(stream, typeof(T)));
}
protected override object DeserializeInternal(DeserializationStream stream, Type sourceType)
{
Type collectionType = sourceType;
if (collectionType == typeof(object))
{
collectionType = typeof(List <object>);
}
var deserializedCollection = Activator.CreateInstance(collectionType);
bool isDictionary = TypeHelper.IsDictionary(deserializedCollection);
bool isLinkedList = TypeHelper.IsLinkedList(deserializedCollection);
IList deserializedCollectionAsList = null;
IDictionary deserializedCollectionAsDictionary = null;
if (isDictionary)
{
deserializedCollectionAsDictionary = (IDictionary)deserializedCollection;
}
else if (isLinkedList)
{
Type listType = typeof(List <>).MakeGenericType(sourceType.GenericTypeArguments);
deserializedCollectionAsList = (IList)Activator.CreateInstance(listType);
}
else
{
deserializedCollectionAsList = (IList)deserializedCollection;
}
if (!stream.HasEnded)
{
BinaryConverter converter = new BinaryConverter();
int sizeCollection = stream.ReadInt();
for (int i = 0; i < sizeCollection; i++)
{
int sizeData = stream.ReadInt();
if (sizeData == 0)
{
continue;
}
byte[] dataValue = stream.ReadBytes(sizeData);
MethodInfo method = typeof(BinaryConverter).GetRuntimeMethod("Deserialize", new[] { typeof(byte[]) });
if (sourceType.GenericTypeArguments.Length > 0)
{
if (isDictionary)
{
Type elementType = typeof(KeyValuePair <,>).MakeGenericType(sourceType.GenericTypeArguments);
method = method.MakeGenericMethod(elementType);
}
else
{
method = method.MakeGenericMethod(sourceType.GenericTypeArguments);
}
}
else
{
method = method.MakeGenericMethod(typeof(object));
}
var deserializeItem = method.Invoke(converter, new object[] { dataValue });
if (isDictionary)
{
KeyValuePair <object, object> keyValuePairFormObject = TypeHelper.CastFrom(deserializeItem);
deserializedCollectionAsDictionary.Add(keyValuePairFormObject.Key, keyValuePairFormObject.Value);
}
else
{
deserializedCollectionAsList.Add(deserializeItem);
}
}
}
if (isLinkedList)
{
deserializedCollection = Activator.CreateInstance(collectionType, deserializedCollectionAsList);
}
return(deserializedCollection);
}
protected override object DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(null);
}
protected override string DeserializeInternal(DeserializationStream stream, Type sourceType)
{
return(stream.ReadUtf8WithSizePrefix());
}
protected abstract T DeserializeInternal(DeserializationStream stream, Type sourceType);
