public void GuidTest()
{
var guid = Guid.NewGuid();
var idx = 0;
var writer = new MessagePackWriter(16);
ExtBinaryGuidFormatter.Instance.Serialize(ref writer, ref idx, guid, null);
idx.Is(18);
var buffer = writer.ToArray(idx);
var reader = new MessagePackReader(buffer);
ExtBinaryGuidFormatter.Instance.Deserialize(ref reader, null).Is(guid);
reader.CurrentSpanIndex.Is(18);
reader = new MessagePackReader(buffer);
var result = reader.ReadExtensionFormat();
#if NETCOREAPP_2_0_GREATER
(new Guid(result.Data)).Is(guid);
#else
(new Guid(result.Data.ToArray())).Is(guid);
#endif
reader.CurrentSpanIndex.Is(18);
}
public void ExtTest(sbyte typeCode, byte[] target)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.WriteExtensionFormat(new ExtensionResult(typeCode, target));
writer.Flush();
var returnLength = sequence.Length;
MsgPack.Packer referencePacked = packer.PackExtendedTypeValue((byte)typeCode, target);
referencePacked.Position.Is(returnLength);
referencePacked.Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
ExtensionResult ext = sequenceReader.ReadExtensionFormat();
ext.TypeCode.Is(typeCode);
ext.Data.ToArray().SequenceEqual(target).IsTrue();
sequenceReader.End.IsTrue();
MsgPack.MessagePackExtendedTypeObject ext2 = this.CreateUnpackedReference(sequence).AsMessagePackExtendedTypeObject();
ext2.TypeCode.Is((byte)ext.TypeCode);
ext2.GetBody().SequenceEqual(ext.Data.ToArray()).IsTrue();
}
public T[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
return(null);
}
var ext = reader.ReadExtensionFormat();
if (ext.Header.TypeCode != TypeCode)
{
throw new InvalidOperationException("Invalid typeCode.");
}
var extReader = new MessagePackReader(ext.Data);
var isLittleEndian = extReader.ReadBoolean();
// extReader.read
byte[] rentMemory = default;
ReadOnlySpan <byte> span = default;
{
var seqSlice = extReader.Sequence.Slice(extReader.Position);
if (isLittleEndian != BitConverter.IsLittleEndian)
{
rentMemory = ArrayPool <byte> .Shared.Rent((int)seqSlice.Length);
seqSlice.CopyTo(rentMemory);
Array.Reverse(rentMemory);
span = rentMemory;
}
else
{
if (seqSlice.IsSingleSegment)
{
span = seqSlice.First.Span;
}
else
{
rentMemory = ArrayPool <byte> .Shared.Rent((int)seqSlice.Length);
seqSlice.CopyTo(rentMemory);
span = rentMemory;
}
}
}
var result = new T[span.Length / StructLength];
Unsafe.CopyBlockUnaligned(ref Unsafe.As <T, byte>(ref result[0]), ref MemoryMarshal.GetReference(span), (uint)span.Length);
return(result);
}
static T DeserializeWithLengthPrefixExt2 <T>(Stream stream, IFormatterResolver resolver)
{
const int ExtTypeCode = 111; // sample ext code
using (var output = new ArrayBufferWriter(16))
{
MessagePackBinary.ReadMessageBlockFromStreamUnsafe(stream, output);
var reader = new MessagePackReader(output.WrittenSpan);
var header = reader.ReadExtensionFormat();
if (header.TypeCode == ExtTypeCode)
{
return(MessagePackSerializer.Deserialize <T>(header.Data, resolver));
}
else
{
throw new Exception();
}
}
}