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