/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_DATETIME: return((DateTimeOffset)Reader.ReadDateTime());
case ObjectSerializer.TYPE_DATETIMEOFFSET: return(Reader.ReadDateTimeOffset());
case ObjectSerializer.TYPE_STRING:
case ObjectSerializer.TYPE_CI_STRING: return(DateTimeOffset.Parse(Reader.ReadString()));
case ObjectSerializer.TYPE_MIN: return(DateTimeOffset.MinValue);
case ObjectSerializer.TYPE_MAX: return(DateTimeOffset.MaxValue);
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a DateTimeOffset value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
return(ReadArray <T>(this.provider, Reader, DataType.Value));
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_ENUM:
case ObjectSerializer.TYPE_STRING:
case ObjectSerializer.TYPE_CI_STRING: return(Reader.ReadString());
case ObjectSerializer.TYPE_CHAR: return(new string(Reader.ReadChar(), 1));
case ObjectSerializer.TYPE_BOOLEAN: return(Reader.ReadBoolean().ToString());
case ObjectSerializer.TYPE_BYTE: return(Reader.ReadString().ToString());
case ObjectSerializer.TYPE_INT16: return(Reader.ReadInt16().ToString());
case ObjectSerializer.TYPE_INT32: return(Reader.ReadInt32().ToString());
case ObjectSerializer.TYPE_INT64: return(Reader.ReadInt64().ToString());
case ObjectSerializer.TYPE_SBYTE: return(Reader.ReadSByte().ToString());
case ObjectSerializer.TYPE_UINT16: return(Reader.ReadUInt16().ToString());
case ObjectSerializer.TYPE_UINT32: return(Reader.ReadUInt32().ToString());
case ObjectSerializer.TYPE_UINT64: return(Reader.ReadUInt64().ToString());
case ObjectSerializer.TYPE_DECIMAL: return(Reader.ReadDecimal().ToString());
case ObjectSerializer.TYPE_DOUBLE: return(Reader.ReadDouble().ToString());
case ObjectSerializer.TYPE_SINGLE: return(Reader.ReadSingle().ToString());
case ObjectSerializer.TYPE_GUID: return(Reader.ReadGuid().ToString());
case ObjectSerializer.TYPE_DATETIME: return(Reader.ReadDateTime().ToString());
case ObjectSerializer.TYPE_DATETIMEOFFSET: return(Reader.ReadDateTimeOffset().ToString());
case ObjectSerializer.TYPE_TIMESPAN: return(Reader.ReadTimeSpan().ToString());
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a string value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_BYTEARRAY: return(Reader.ReadByteArray());
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a byte array.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_CHAR: return((char?)Reader.ReadChar());
case ObjectSerializer.TYPE_BYTE: return((char?)Reader.ReadByte());
case ObjectSerializer.TYPE_INT16: return((char?)Reader.ReadInt16());
case ObjectSerializer.TYPE_INT32: return((char?)Reader.ReadInt32());
case ObjectSerializer.TYPE_INT64: return((char?)Reader.ReadInt64());
case ObjectSerializer.TYPE_SBYTE: return((char?)Reader.ReadSByte());
case ObjectSerializer.TYPE_UINT16: return((char?)Reader.ReadUInt16());
case ObjectSerializer.TYPE_UINT32: return((char?)Reader.ReadUInt32());
case ObjectSerializer.TYPE_UINT64: return((char?)Reader.ReadUInt64());
case ObjectSerializer.TYPE_DECIMAL: return((char?)Reader.ReadDecimal());
case ObjectSerializer.TYPE_DOUBLE: return((char?)Reader.ReadDouble());
case ObjectSerializer.TYPE_SINGLE: return((char?)Reader.ReadSingle());
case ObjectSerializer.TYPE_MIN: return(char.MinValue);
case ObjectSerializer.TYPE_MAX: return(char.MaxValue);
case ObjectSerializer.TYPE_NULL: return(null);
case ObjectSerializer.TYPE_STRING:
case ObjectSerializer.TYPE_CI_STRING:
string s = Reader.ReadString();
return(string.IsNullOrEmpty(s) ? (char?)0 : s[0]);
default: throw new Exception("Expected a nullable char value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_BOOLEAN: return(Reader.ReadBoolean() ? (sbyte?)1 : (sbyte?)0);
case ObjectSerializer.TYPE_BYTE: return((sbyte?)Reader.ReadByte());
case ObjectSerializer.TYPE_INT16: return((sbyte?)Reader.ReadInt16());
case ObjectSerializer.TYPE_INT32: return((sbyte?)Reader.ReadInt32());
case ObjectSerializer.TYPE_INT64: return((sbyte?)Reader.ReadInt64());
case ObjectSerializer.TYPE_SBYTE: return((sbyte?)Reader.ReadSByte());
case ObjectSerializer.TYPE_UINT16: return((sbyte?)Reader.ReadUInt16());
case ObjectSerializer.TYPE_UINT32: return((sbyte?)Reader.ReadUInt32());
case ObjectSerializer.TYPE_UINT64: return((sbyte?)Reader.ReadUInt64());
case ObjectSerializer.TYPE_DECIMAL: return((sbyte?)Reader.ReadDecimal());
case ObjectSerializer.TYPE_DOUBLE: return((sbyte?)Reader.ReadDouble());
case ObjectSerializer.TYPE_SINGLE: return((sbyte?)Reader.ReadSingle());
case ObjectSerializer.TYPE_STRING:
case ObjectSerializer.TYPE_CI_STRING: return((sbyte?)sbyte.Parse(Reader.ReadString()));
case ObjectSerializer.TYPE_MIN: return(sbyte.MinValue);
case ObjectSerializer.TYPE_MAX: return(sbyte.MaxValue);
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a nullable sbyte value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_GUID: return((Guid?)Reader.ReadGuid());
case ObjectSerializer.TYPE_STRING: return((Guid?)Guid.Parse(Reader.ReadString()));
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a nullable Guid value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_BOOLEAN: return(Enum.ToObject(this.enumType, Reader.ReadBoolean() ? 1 : 0));
case ObjectSerializer.TYPE_BYTE: return(Enum.ToObject(this.enumType, Reader.ReadByte()));
case ObjectSerializer.TYPE_INT16: return(Enum.ToObject(this.enumType, Reader.ReadInt16()));
case ObjectSerializer.TYPE_INT32: return(Enum.ToObject(this.enumType, Reader.ReadInt32()));
case ObjectSerializer.TYPE_INT64: return(Enum.ToObject(this.enumType, Reader.ReadInt64()));
case ObjectSerializer.TYPE_SBYTE: return(Enum.ToObject(this.enumType, Reader.ReadSByte()));
case ObjectSerializer.TYPE_UINT16: return(Enum.ToObject(this.enumType, Reader.ReadUInt16()));
case ObjectSerializer.TYPE_UINT32: return(Enum.ToObject(this.enumType, Reader.ReadUInt32()));
case ObjectSerializer.TYPE_UINT64: return(Enum.ToObject(this.enumType, Reader.ReadUInt64()));
case ObjectSerializer.TYPE_DECIMAL: return(Enum.ToObject(this.enumType, Reader.ReadDecimal()));
case ObjectSerializer.TYPE_DOUBLE: return(Enum.ToObject(this.enumType, Reader.ReadDouble()));
case ObjectSerializer.TYPE_SINGLE: return(Enum.ToObject(this.enumType, Reader.ReadSingle()));
case ObjectSerializer.TYPE_STRING:
case ObjectSerializer.TYPE_CI_STRING: return(Enum.Parse(this.enumType, Reader.ReadString()));
case ObjectSerializer.TYPE_ENUM: return(Reader.ReadEnum(this.enumType));
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected an enum value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_BOOLEAN: return(Reader.ReadBoolean());
case ObjectSerializer.TYPE_BYTE: return(Reader.ReadByte() != 0);
case ObjectSerializer.TYPE_INT16: return(Reader.ReadInt16() != 0);
case ObjectSerializer.TYPE_INT32: return(Reader.ReadInt32() != 0);
case ObjectSerializer.TYPE_INT64: return(Reader.ReadInt64() != 0);
case ObjectSerializer.TYPE_SBYTE: return(Reader.ReadSByte() != 0);
case ObjectSerializer.TYPE_UINT16: return(Reader.ReadUInt16() != 0);
case ObjectSerializer.TYPE_UINT32: return(Reader.ReadUInt32() != 0);
case ObjectSerializer.TYPE_UINT64: return(Reader.ReadUInt64() != 0);
case ObjectSerializer.TYPE_DECIMAL: return(Reader.ReadDecimal() != 0);
case ObjectSerializer.TYPE_DOUBLE: return(Reader.ReadDouble() != 0);
case ObjectSerializer.TYPE_SINGLE: return(Reader.ReadSingle() != 0);
case ObjectSerializer.TYPE_MIN: return(false);
case ObjectSerializer.TYPE_MAX: return(true);
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a boolean value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded)
{
if (!DataType.HasValue)
{
DataType = Reader.ReadBits(6);
}
switch (DataType.Value)
{
case ObjectSerializer.TYPE_TIMESPAN: return(Reader.ReadTimeSpan());
case ObjectSerializer.TYPE_STRING: return(TimeSpan.Parse(Reader.ReadString()));
case ObjectSerializer.TYPE_MIN: return(TimeSpan.MinValue);
case ObjectSerializer.TYPE_MAX: return(TimeSpan.MaxValue);
case ObjectSerializer.TYPE_NULL: return(null);
default: throw new Exception("Expected a TimeSpan value.");
}
}
/// <summary>
/// Gets the full payload size of the next objet.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <returns>Full payloa size.</returns>
public uint GetFullPayloadSize(BinaryDeserializer Reader)
{
int Pos = Reader.Position;
uint DataType = Reader.ReadBits(6);
switch (DataType)
{
case ObjectSerializer.TYPE_OBJECT:
string TypeName = Reader.ReadString();
IObjectSerializer Serializer;
if (string.IsNullOrEmpty(TypeName))
{
Serializer = this.genericSerializer;
}
else
{
Type T = Types.GetType(TypeName);
if (!(T is null))
{
Serializer = this.provider.GetObjectSerializer(T);
}
public void DBFiles_BinSerialization_Test_01_Serialization()
{
BinarySerializer Serializer = new BinarySerializer(string.Empty, Encoding.UTF8, true);
Serializer.Write(true);
Serializer.Write(false);
Serializer.Write((byte)25);
Serializer.Write((short)1234);
Serializer.Write((short)-1234);
Serializer.Write((int)12345678);
Serializer.Write((int)-12345678);
Serializer.Write((long)1234567890123456789);
Serializer.Write((long)-1234567890123456789);
Serializer.Write((sbyte)-45);
Serializer.Write((ushort)1234);
Serializer.Write((uint)12345678);
Serializer.Write((ulong)1234567890123456789);
Serializer.Write((decimal)1234567890.123456789);
Serializer.Write(1234567890.123456789);
Serializer.Write(1234567890.123456789f);
Serializer.Write(new DateTime(2016, 10, 06, 20, 32, 0));
Serializer.Write(new TimeSpan(1, 2, 3, 4, 5));
Serializer.Write('☀');
Serializer.Write(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
Serializer.Write("Today, there will be a lot of ☀.");
Serializer.WriteVariableLengthUInt64(0);
Serializer.WriteVariableLengthUInt64(100);
Serializer.WriteVariableLengthUInt64(10000);
Serializer.WriteVariableLengthUInt64(1000000);
Serializer.WriteVariableLengthUInt64(100000000);
Serializer.WriteVariableLengthUInt64(10000000000);
Serializer.WriteVariableLengthUInt64(1000000000000);
Serializer.WriteVariableLengthUInt64(100000000000000);
Serializer.WriteVariableLengthUInt64(10000000000000000);
Serializer.WriteBit(false);
Serializer.WriteBit(true);
Serializer.WriteBits(10, 4);
Serializer.WriteBits(100, 7);
Serializer.WriteBits(1000, 10);
Serializer.WriteBits(10000, 14);
Serializer.Write(NormalEnum.Option2);
Serializer.Write(FlagsEnum.Option2 | FlagsEnum.Option4);
byte[] Data = Serializer.GetSerialization();
BinaryDeserializer Deserializer = new BinaryDeserializer(string.Empty, Encoding.UTF8, Data, true);
AssertEx.Same(true, Deserializer.ReadBoolean());
AssertEx.Same(false, Deserializer.ReadBoolean());
AssertEx.Same((byte)25, Deserializer.ReadByte());
AssertEx.Same((short)1234, Deserializer.ReadInt16());
AssertEx.Same((short)-1234, Deserializer.ReadInt16());
AssertEx.Same((int)12345678, Deserializer.ReadInt32());
AssertEx.Same((int)-12345678, Deserializer.ReadInt32());
AssertEx.Same((long)1234567890123456789, Deserializer.ReadInt64());
AssertEx.Same((long)-1234567890123456789, Deserializer.ReadInt64());
AssertEx.Same((sbyte)-45, Deserializer.ReadSByte());
AssertEx.Same((ushort)1234, Deserializer.ReadUInt16());
AssertEx.Same((uint)12345678, Deserializer.ReadUInt32());
AssertEx.Same((ulong)1234567890123456789, Deserializer.ReadUInt64());
AssertEx.Same((decimal)1234567890.123456789, Deserializer.ReadDecimal());
AssertEx.Same(1234567890.123456789, Deserializer.ReadDouble());
AssertEx.Same(1234567890.123456789f, Deserializer.ReadSingle());
AssertEx.Same(new DateTime(2016, 10, 06, 20, 32, 0), Deserializer.ReadDateTime());
AssertEx.Same(new TimeSpan(1, 2, 3, 4, 5), Deserializer.ReadTimeSpan());
AssertEx.Same('☀', Deserializer.ReadChar());
AssertEx.Same(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, Deserializer.ReadByteArray());
AssertEx.Same("Today, there will be a lot of ☀.", Deserializer.ReadString());
AssertEx.Same(0, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(100, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(10000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(1000000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(100000000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(10000000000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(1000000000000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(100000000000000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(10000000000000000, Deserializer.ReadVariableLengthUInt64());
AssertEx.Same(false, Deserializer.ReadBit());
AssertEx.Same(true, Deserializer.ReadBit());
AssertEx.Same(10, Deserializer.ReadBits(4));
AssertEx.Same(100, Deserializer.ReadBits(7));
AssertEx.Same(1000, Deserializer.ReadBits(10));
AssertEx.Same(10000, Deserializer.ReadBits(14));
AssertEx.Same(NormalEnum.Option2, Deserializer.ReadEnum(typeof(NormalEnum)));
AssertEx.Same(FlagsEnum.Option2 | FlagsEnum.Option4, Deserializer.ReadEnum(typeof(FlagsEnum)));
}
/// <summary>
/// Gets the full payload size of the next objet.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <returns>Full payloa size.</returns>
public uint GetFullPayloadSize(BinaryDeserializer Reader)
{
int Pos = Reader.Position;
uint DataType = Reader.ReadBits(6);
switch (DataType)
{
case ObjectSerializer.TYPE_OBJECT:
string TypeName = Reader.ReadString();
IObjectSerializer Serializer;
if (string.IsNullOrEmpty(TypeName))
{
Serializer = this.genericSerializer;
}
else
{
Type T = Types.GetType(TypeName);
if (T != null)
{
Serializer = this.provider.GetObjectSerializer(T);
}
else
{
Serializer = this.genericSerializer;
}
}
Reader.Position = Pos;
Serializer.Deserialize(Reader, ObjectSerializer.TYPE_OBJECT, false);
break;
case ObjectSerializer.TYPE_BOOLEAN:
Reader.SkipBit();
break;
case ObjectSerializer.TYPE_BYTE:
Reader.SkipByte();
break;
case ObjectSerializer.TYPE_INT16:
Reader.SkipInt16();
break;
case ObjectSerializer.TYPE_INT32:
Reader.SkipInt32();
break;
case ObjectSerializer.TYPE_INT64:
Reader.SkipInt64();
break;
case ObjectSerializer.TYPE_SBYTE:
Reader.SkipSByte();
break;
case ObjectSerializer.TYPE_UINT16:
Reader.SkipUInt16();
break;
case ObjectSerializer.TYPE_UINT32:
Reader.SkipUInt32();
break;
case ObjectSerializer.TYPE_UINT64:
Reader.SkipUInt64();
break;
case ObjectSerializer.TYPE_DECIMAL:
Reader.SkipDecimal();
break;
case ObjectSerializer.TYPE_DOUBLE:
Reader.SkipDouble();
break;
case ObjectSerializer.TYPE_SINGLE:
Reader.SkipSingle();
break;
case ObjectSerializer.TYPE_DATETIME:
Reader.SkipDateTime();
break;
case ObjectSerializer.TYPE_TIMESPAN:
Reader.SkipTimeSpan();
break;
case ObjectSerializer.TYPE_CHAR:
Reader.SkipChar();
break;
case ObjectSerializer.TYPE_STRING:
Reader.SkipString();
break;
case ObjectSerializer.TYPE_ENUM:
Reader.SkipString();
break;
case ObjectSerializer.TYPE_BYTEARRAY:
Reader.SkipByteArray();
break;
case ObjectSerializer.TYPE_GUID:
Reader.SkipGuid();
break;
case ObjectSerializer.TYPE_NULL:
break;
default:
throw new Exception("Object or value expected.");
}
Reader.FlushBits();
uint Len = (uint)(Reader.Position - Pos);
Reader.Position = Pos;
return(Len);
}
private async Task <KeyValuePair <uint, uint> > GetSize(BinaryDeserializer Reader)
{
int Pos = Reader.Position;
uint DataType = Reader.ReadBits(6);
switch (DataType)
{
case ObjectSerializer.TYPE_OBJECT:
ulong TypeCode = Reader.ReadVariableLengthUInt64();
ulong CollectionCode = Reader.ReadVariableLengthUInt64();
string CollectionName = await this.provider.GetFieldName(null, CollectionCode);
string TypeName = await this.provider.GetFieldName(CollectionName, TypeCode);
IObjectSerializer Serializer;
if (string.IsNullOrEmpty(TypeName))
{
Serializer = this.genericSerializer;
}
else
{
Type T = Types.GetType(TypeName);
if (T is null)
{
Serializer = this.genericSerializer;
}
else
{
Serializer = await this.provider.GetObjectSerializer(T);
}
}
Reader.Position = Pos + 1;
await Serializer.Deserialize(Reader, ObjectSerializer.TYPE_OBJECT, true);
break;
case ObjectSerializer.TYPE_BOOLEAN:
Reader.SkipBit();
break;
case ObjectSerializer.TYPE_BYTE:
Reader.SkipByte();
break;
case ObjectSerializer.TYPE_INT16:
Reader.SkipInt16();
break;
case ObjectSerializer.TYPE_INT32:
Reader.SkipInt32();
break;
case ObjectSerializer.TYPE_INT64:
Reader.SkipInt64();
break;
case ObjectSerializer.TYPE_SBYTE:
Reader.SkipSByte();
break;
case ObjectSerializer.TYPE_UINT16:
Reader.SkipUInt16();
break;
case ObjectSerializer.TYPE_UINT32:
Reader.SkipUInt32();
break;
case ObjectSerializer.TYPE_UINT64:
Reader.SkipUInt64();
break;
case ObjectSerializer.TYPE_DECIMAL:
Reader.SkipDecimal();
break;
case ObjectSerializer.TYPE_DOUBLE:
Reader.SkipDouble();
break;
case ObjectSerializer.TYPE_SINGLE:
Reader.SkipSingle();
break;
case ObjectSerializer.TYPE_DATETIME:
Reader.SkipDateTime();
break;
case ObjectSerializer.TYPE_DATETIMEOFFSET:
Reader.SkipDateTimeOffset();
break;
case ObjectSerializer.TYPE_TIMESPAN:
Reader.SkipTimeSpan();
break;
case ObjectSerializer.TYPE_CHAR:
Reader.SkipChar();
break;
case ObjectSerializer.TYPE_STRING:
case ObjectSerializer.TYPE_CI_STRING:
case ObjectSerializer.TYPE_ENUM:
Reader.SkipString();
break;
case ObjectSerializer.TYPE_BYTEARRAY:
Reader.SkipByteArray();
break;
case ObjectSerializer.TYPE_GUID:
Reader.SkipGuid();
break;
case ObjectSerializer.TYPE_NULL:
break;
case ObjectSerializer.TYPE_ARRAY:
throw new Exception("Arrays must be embedded in objects.");
case ObjectSerializer.TYPE_MAX: // BLOB
return(new KeyValuePair <uint, uint>(4, (uint)Reader.ReadVariableLengthUInt64()));
default:
throw new Exception("Object or value expected.");
}
Reader.FlushBits();
uint Size = (uint)(Reader.Position - Pos);
Reader.Position = Pos;
return(new KeyValuePair <uint, uint>(Size, Size));
}
