private T ReadFullObject <T>(int pos)
{
var hdr = BinaryObjectHeader.Read(Stream, pos);
// Validate protocol version.
BinaryUtils.ValidateProtocolVersion(hdr.Version);
try
{
// Already read this object?
object hndObj;
if (_hnds != null && _hnds.TryGetValue(pos, out hndObj))
{
return((T)hndObj);
}
if (hdr.IsUserType && _mode == BinaryMode.ForceBinary)
{
BinaryObject portObj;
if (_detach)
{
Stream.Seek(pos, SeekOrigin.Begin);
portObj = new BinaryObject(_marsh, Stream.ReadByteArray(hdr.Length), 0, hdr);
}
else
{
portObj = new BinaryObject(_marsh, Stream.GetArray(), pos, hdr);
}
T obj = _builder == null ? TypeCaster <T> .Cast(portObj) : TypeCaster <T> .Cast(_builder.Child(portObj));
AddHandle(pos, obj);
return(obj);
}
else
{
// Find descriptor.
var desc = _marsh.GetDescriptor(hdr.IsUserType, hdr.TypeId);
// Instantiate object.
if (desc.Type == null)
{
if (desc is BinarySurrogateTypeDescriptor)
{
throw new BinaryObjectException("Unknown type ID: " + hdr.TypeId);
}
throw new BinaryObjectException("No matching type found for object [typeId=" +
desc.TypeId + ", typeName=" + desc.TypeName + ']');
}
// Preserve old frame.
var oldHdr = _curHdr;
int oldPos = _curPos;
var oldStruct = _curStruct;
bool oldRaw = _curRaw;
var oldSchema = _curSchema;
var oldSchemaMap = _curSchemaMap;
// Set new frame.
_curHdr = hdr;
_curPos = pos;
SetCurSchema(desc);
_curStruct = new BinaryStructureTracker(desc, desc.ReaderTypeStructure);
_curRaw = false;
// Read object.
Stream.Seek(pos + BinaryObjectHeader.Size, SeekOrigin.Begin);
var obj = desc.Serializer.ReadBinary <T>(this, desc.Type, pos);
_curStruct.UpdateReaderStructure();
// Restore old frame.
_curHdr = oldHdr;
_curPos = oldPos;
_curStruct = oldStruct;
_curRaw = oldRaw;
_curSchema = oldSchema;
_curSchemaMap = oldSchemaMap;
return(obj);
}
}
finally
{
// Advance stream pointer.
Stream.Seek(pos + hdr.Length, SeekOrigin.Begin);
}
}
/// <summary>
/// Write object.
/// </summary>
/// <param name="obj">Object.</param>
public void Write <T>(T obj)
{
// Handle special case for null.
if (obj == null)
{
_stream.WriteByte(BinaryUtils.HdrNull);
return;
}
// We use GetType() of a real object instead of typeof(T) to take advantage of
// automatic Nullable'1 unwrapping.
Type type = obj.GetType();
// Handle common case when primitive is written.
if (type.IsPrimitive)
{
WritePrimitive(obj, type);
return;
}
// Handle special case for builder.
if (WriteBuilderSpecials(obj))
{
return;
}
// Suppose that we faced normal object and perform descriptor lookup.
IBinaryTypeDescriptor desc = type.IsEnum ? null : _marsh.GetDescriptor(type);
if (desc != null)
{
// Writing normal object.
var pos = _stream.Position;
// Dealing with handles.
if (!(desc.Serializer is IBinarySystemTypeSerializer) && WriteHandle(pos, obj))
{
return;
}
// Skip header length as not everything is known now
_stream.Seek(BinaryObjectHeader.Size, SeekOrigin.Current);
// Preserve old frame.
int oldTypeId = _curTypeId;
IBinaryNameMapper oldConverter = _curConverter;
IBinaryIdMapper oldMapper = _curMapper;
int oldRawPos = _curRawPos;
var oldPos = _curPos;
var oldStruct = _curStruct;
// Push new frame.
_curTypeId = desc.TypeId;
_curConverter = desc.NameMapper;
_curMapper = desc.IdMapper;
_curRawPos = 0;
_curPos = pos;
_curStruct = new BinaryStructureTracker(desc, desc.WriterTypeStructure);
var schemaIdx = _schema.PushSchema();
try
{
// Write object fields.
desc.Serializer.WriteBinary(obj, this);
// Write schema
var schemaOffset = _stream.Position - pos;
int schemaId;
var flags = desc.UserType
? BinaryObjectHeader.Flag.UserType
: BinaryObjectHeader.Flag.None;
var hasSchema = _schema.WriteSchema(_stream, schemaIdx, out schemaId, ref flags);
if (hasSchema)
{
flags |= BinaryObjectHeader.Flag.HasSchema;
// Calculate and write header.
if (_curRawPos > 0)
{
_stream.WriteInt(_curRawPos - pos); // raw offset is in the last 4 bytes
}
}
else
{
schemaOffset = BinaryObjectHeader.Size;
}
if (_curRawPos > 0)
{
flags |= BinaryObjectHeader.Flag.HasRaw;
}
var len = _stream.Position - pos;
var header = new BinaryObjectHeader(desc.TypeId, obj.GetHashCode(), len,
schemaId, schemaOffset, flags);
BinaryObjectHeader.Write(header, _stream, pos);
Stream.Seek(pos + len, SeekOrigin.Begin); // Seek to the end
}
finally
{
_schema.PopSchema(schemaIdx);
}
// Apply structure updates if any.
_curStruct.UpdateWriterStructure(this);
// Restore old frame.
_curTypeId = oldTypeId;
_curConverter = oldConverter;
_curMapper = oldMapper;
_curRawPos = oldRawPos;
_curPos = oldPos;
_curStruct = oldStruct;
}
else
{
// Are we dealing with a well-known type?
var handler = BinarySystemHandlers.GetWriteHandler(type);
if (handler == null) // We did our best, object cannot be marshalled.
{
throw new BinaryObjectException("Unsupported object type [type=" + type + ", object=" + obj + ']');
}
handler(this, obj);
}
}
private T ReadFullObject <T>(int pos)
{
var hdr = BinaryObjectHeader.Read(Stream, pos);
// Validate protocol version.
BinaryUtils.ValidateProtocolVersion(hdr.Version);
try
{
// Already read this object?
object hndObj;
if (_hnds != null && _hnds.TryGetValue(pos, out hndObj))
{
return((T)hndObj);
}
if (hdr.IsUserType && _mode == BinaryMode.ForceBinary)
{
BinaryObject portObj;
if (_detach)
{
Stream.Seek(pos, SeekOrigin.Begin);
portObj = new BinaryObject(_marsh, Stream.ReadByteArray(hdr.Length), 0, hdr);
}
else
{
portObj = new BinaryObject(_marsh, Stream.GetArray(), pos, hdr);
}
T obj = _builder == null ? TypeCaster <T> .Cast(portObj) : TypeCaster <T> .Cast(_builder.Child(portObj));
AddHandle(pos, obj);
return(obj);
}
else
{
// Find descriptor.
IBinaryTypeDescriptor desc;
if (!_descs.TryGetValue(BinaryUtils.TypeKey(hdr.IsUserType, hdr.TypeId), out desc))
{
throw new BinaryObjectException("Unknown type ID: " + hdr.TypeId);
}
// Instantiate object.
if (desc.Type == null)
{
throw new BinaryObjectException("No matching type found for object [typeId=" +
desc.TypeId + ", typeName=" + desc.TypeName + ']');
}
// Preserve old frame.
var oldHdr = _curHdr;
int oldPos = _curPos;
var oldStruct = _curStruct;
bool oldRaw = _curRaw;
var oldSchema = _curSchema;
var oldSchemaMap = _curSchemaMap;
// Set new frame.
_curHdr = hdr;
_curPos = pos;
SetCurSchema(desc);
_curStruct = new BinaryStructureTracker(desc, desc.ReaderTypeStructure);
_curRaw = false;
// Read object.
Stream.Seek(pos + BinaryObjectHeader.Size, SeekOrigin.Begin);
object obj;
var sysSerializer = desc.Serializer as IBinarySystemTypeSerializer;
if (sysSerializer != null)
{
obj = sysSerializer.ReadInstance(this);
}
else
{
try
{
obj = FormatterServices.GetUninitializedObject(desc.Type);
// Save handle.
AddHandle(pos, obj);
}
catch (Exception e)
{
throw new BinaryObjectException("Failed to create type instance: " +
desc.Type.AssemblyQualifiedName, e);
}
desc.Serializer.ReadBinary(obj, this);
}
_curStruct.UpdateReaderStructure();
// Restore old frame.
_curHdr = oldHdr;
_curPos = oldPos;
_curStruct = oldStruct;
_curRaw = oldRaw;
_curSchema = oldSchema;
_curSchemaMap = oldSchemaMap;
// Process wrappers. We could introduce a common interface, but for only 2 if-else is faster.
var wrappedSerializable = obj as SerializableObjectHolder;
if (wrappedSerializable != null)
{
return((T)wrappedSerializable.Item);
}
var wrappedDateTime = obj as DateTimeHolder;
if (wrappedDateTime != null)
{
return(TypeCaster <T> .Cast(wrappedDateTime.Item));
}
return((T)obj);
}
}
finally
{
// Advance stream pointer.
Stream.Seek(pos + hdr.Length, SeekOrigin.Begin);
}
}
