public override void Serialize(Array item, Stream target)
{
var buffer = BinarySerializerService.SingletonBitConverter.GetBytes(item.Length);
target.Write(buffer, 0, buffer.Length);
foreach (var element in item)
{
if (null == element)
{
target.WriteByte(0x00);
continue;
}
var type = element.GetType();
var name = type.AssemblyQualifiedName;
if (null == name)
{
target.WriteByte(0x00);
continue;
}
target.WriteByte(0x01);
Trace.WriteLine(string.Format("Writing element at {0}", target.Position));
var textBuffer = TextEncoding.GetBytes(name);
buffer = BinarySerializerService.SingletonBitConverter.GetBytes(textBuffer.Length);
target.Write(buffer, 0, buffer.Length);
target.Write(textBuffer, 0, textBuffer.Length);
var serializer = BinarySerializerService.GetSerializer(type);
serializer.Serialize(element, target);
}
}
// ReSharper restore StaticFieldInGenericType
/// <summary>
/// Serializes the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="target">The target.</param>
public override void Serialize(T item, Stream target)
{
foreach (var member in Graph)
{
ISerializer serializer;
var value = member.IsDelegate ? null : member.GetValue(item);
if (null == value || member.IsUntyped)
{
value = value ?? new NullType();
var type = value.GetType();
serializer = BinarySerializerService.GetSerializer(type);
target.WriteByte(0x01); // Indicate that we need to read the type when we deserialize.
WriteType(target, type);
}
else
{
target.WriteByte(0x00); // Indicate that we do NOT need to read the type when we deserialize.
serializer = member.TypeSerializer;
}
try
{
serializer.Serialize(value, target);
}
catch (Exception e)
{
PostQuit(e, MethodBase.GetCurrentMethod());
break;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BinaryPrimitives.ArraySerializer" /> class.
/// </summary>
/// <param name="arrayType">Type of the array.</param>
/// <exception cref="WhatTheFuckException"></exception>
public ArraySerializer(Type arrayType)
{
if (!arrayType.IsArray)
{
throw new WhatTheFuckException();
}
elementType = arrayType.GetElementType();
itemSerializer = BinarySerializerService.GetSerializer(elementType);
if (null == itemSerializer)
{
throw new WhatTheFuckException();
}
}
public override Array Deserialize(Stream source)
{
var buffer = new byte[sizeof(int)];
source.Read(buffer, 0, buffer.Length);
var elementCount = BinarySerializerService.SingletonBitConverter.ToInt32(buffer);
if (0 > elementCount)
{
throw new InvalidDataException();
}
var target = Array.CreateInstance(arrayType.GetElementType(), elementCount);
for (var i = 0; i < elementCount; ++i)
{
var isNotNull = source.ReadByte();
if (isNotNull == 0)
{
continue;
}
Trace.WriteLine(string.Format("Reading Element at {0}", source.Position));
buffer = new byte[sizeof(int)];
source.Read(buffer, 0, buffer.Length); // Length of the type string
var textLength = BinarySerializerService.SingletonBitConverter.ToInt32(buffer);
if (0 > textLength)
{
throw new InvalidDataException();
}
buffer = new byte[textLength];
source.Read(buffer, 0, buffer.Length);
var typeName = TextEncoding.GetString(buffer);
var elementType = Type.GetType(typeName);
if (null == elementType)
{
continue;
}
var serializer = BinarySerializerService.GetSerializer(elementType);
var item = serializer.Deserialize(source);
target.SetValue(item, i);
}
return(target);
}
/// <summary>
/// Deserializes the specified source.
/// </summary>
/// <param name="source">The source.</param>
/// <returns></returns>
public override T Deserialize(Stream source)
{
var target = Activator.CreateInstance(typeof(T));
foreach (var member in Graph)
{
ISerializer serializer;
var readType = source.ReadByte() == 0x01;
if (readType)
{
var memberType = ReadType(source);
if (null == memberType)
{
continue;
}
serializer = BinarySerializerService.GetSerializer(memberType);
}
else
{
serializer = member.TypeSerializer;
}
var value = serializer.Deserialize(source);
try
{
if (value is NullType)
{
member.SetValue(ref target, null);
}
else
{
member.SetValue(ref target, value);
}
}
catch (Exception e)
{
PostQuit(e, MethodBase.GetCurrentMethod());
break;
}
}
return((T)target);
}
public override int GetOutputSize(T item)
{
var accum = 0;
foreach (var member in Graph)
{
ISerializer serializer;
var value = member.IsDelegate ? null : member.GetValue(item);
if (null == value || member.IsUntyped)
{
value = value ?? new NullType();
var type = value.GetType();
serializer = BinarySerializerService.GetSerializer(type);
}
else
{
serializer = member.TypeSerializer;
}
accum += serializer.GetOutputSize(value);
}
return(accum);
}
