static MessagePackObject UnPack(byte[] bytes)
{
using (var unpack = Unpacker.Create(bytes))
{
if (unpack.ReadObject(out MessagePackObject obj))
{
return(obj);
}
return(MessagePackObject.Nil);
}
//return serializer.UnpackSingleObject(bytes);
}
public static string Request(string input)
{
// prepare Socket
var nanoSock = new NanomsgSocket(Domain.SP, Protocol.REQ);
string result = null;
bool messageReceived = false;
// prepare Listener
var listener = new NanomsgListener();
listener.ReceivedMessage += (sockedId) =>
{
using (NanomsgReadStream inStream = nanoSock.ReceiveStream())
using (var unpacker = Unpacker.Create(inStream))
{
string output;
if (!unpacker.ReadString(out output))
{
throw new Exception("REP invalid");
}
result = output;
}
messageReceived = true;
};
// Connect and Send Request
listener.AddSocket(nanoSock);
nanoSock.Connect("tcp://127.0.0.1:" + reqPort);
using (NanomsgWriteStream outStream = nanoSock.CreateSendStream())
using (var packer = Packer.Create(outStream))
{
packer.PackString(input);
nanoSock.SendStream(outStream);
}
var start = DateTime.Now;
while (!messageReceived && start + TimeSpan.FromSeconds(30) > DateTime.Now)
{
listener.Listen(TimeSpan.FromMilliseconds(250));
}
listener.RemoveSocket(nanoSock);
nanoSock.Dispose();
if (!messageReceived)
{
throw new Exception("REQ timed out");
}
return(result);
}
public void TestIMessagePackSerializerUnpackTo_StreamContainsNull()
{
IMessagePackSerializer target = CreateTarget <int[]>();
using (var buffer = new MemoryStream(new byte[] { 0xC0 }))
using (var unpacker = Unpacker.Create(buffer))
{
unpacker.Read();
var collection = new int[0];
target.UnpackTo(unpacker, collection);
}
}
public void TestDispatch_MethodExists_Success()
{
var svcFile = ".\\Services.svc";
File.WriteAllText(
svcFile,
String.Format(CultureInfo.InvariantCulture, "<% @ ServiceHost Service=\"{0}\" %>", typeof(TestService).FullName)
);
try
{
var configuration = new RpcServerConfiguration();
configuration.ServiceTypeLocatorProvider = conf => new FileBasedServiceTypeLocator();
using (var server = new RpcServer(configuration))
using (var transportManager = new NullServerTransportManager(server))
using (var transport = new NullServerTransport(transportManager))
using (var requestContext = DispatchTestHelper.CreateRequestContext())
using (var argumentsBuffer = new MemoryStream())
using (var waitHandle = new ManualResetEventSlim())
{
var message = Guid.NewGuid().ToString();
using (var argumentsPacker = Packer.Create(argumentsBuffer, false))
{
argumentsPacker.PackArrayHeader(1);
argumentsPacker.Pack(message);
}
argumentsBuffer.Position = 0;
var target = new LocatorBasedDispatcher(server);
MessagePackObject response = MessagePackObject.Nil;
requestContext.MethodName = "Echo:TestService:1";
requestContext.MessageId = 1;
requestContext.SetTransport(transport);
requestContext.ArgumentsUnpacker = Unpacker.Create(argumentsBuffer);
transport.Sent +=
(sender, e) =>
{
response = Unpacking.UnpackString(e.Context.GetReturnValueData()).Value;
waitHandle.Set();
};
target.Dispatch(transport, requestContext);
Assert.That(waitHandle.Wait(TimeSpan.FromSeconds(1)));
Assert.That(message == response, "{0} != {1}", message, response);
}
}
finally
{
File.Delete(svcFile);
}
}
/// <summary>
/// Deserialize object from the <see cref="Stream"/>.
/// </summary>
/// <param name="stream">Source <see cref="Stream"/>.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream"/> is <c>null</c>.
/// </exception>
public object Unpack(Stream stream)
{
// Unpacker does not have finalizer, so just avoiding unpacker disposing prevents stream closing.
var unpacker = Unpacker.Create(stream);
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
return(this.UnpackFrom(unpacker));
}
public void TestIMessagePackSerializerUnpackFrom_Valid_Success()
{
IMessagePackSerializer target = CreateTarget <int>();
using (var buffer = new MemoryStream(new byte[] { 0x1 }))
using (var unpacker = Unpacker.Create(buffer))
{
unpacker.Read();
var result = target.UnpackFrom(unpacker);
Assert.That(result, Is.EqualTo(1));
}
}
public BeerSkipList()
{
var serialize = new BeerListSerializeBenchmark();
_inputStream = PrepareMsgPack(serialize);
_inputBytes = _inputStream.ToArray();
_unpacker = Unpacker.Create(_inputStream);
_msgPackContext = new MsgPackContext();
_msgPackContext.RegisterConverter(new SkipConverter <Beer>());
}
public void TestIMessagePackSerializerUnpackTo_StreamContentIsEmpty()
{
IMessagePackSerializer target = CreateTarget <int[]>();
using (var buffer = new MemoryStream(new byte[0]))
using (var unpacker = Unpacker.Create(buffer))
{
unpacker.Read();
var collection = new int[1];
Assert.Throws <SerializationException>(() => target.UnpackTo(unpacker, collection));
}
}
public void TestIMessagePackSerializerUnpackTo_Valid_Success()
{
IMessagePackSerializer target = CreateTarget <int[]>();
using (var buffer = new MemoryStream(new byte[] { 0x91, 0x1 }))
using (var unpacker = Unpacker.Create(buffer))
{
unpacker.Read();
var collection = new int[2];
target.UnpackTo(unpacker, collection);
// colection[1] is still 0.
Assert.That(collection, Is.EqualTo(new[] { 1, 0 }));
}
}
public static object BytesToObj(Type type, byte[] data)
{
if (data == null || data.Length == 0)
{
return(null);
}
IMessagePackSerializer ser = serDic.GetOrAdd(type, MessagePackSerializer.Create(type));
MemoryStream stream = new MemoryStream(data);
Unpacker up = Unpacker.Create(stream);
up.Read();
return(ser.UnpackFrom(up));
}
public T Get <T>(int index)
{
MemoryStream s = new MemoryStream(buff);
Unpacker _unpacker = Unpacker.Create(s);
for (int i = 0; i < index; i++)
{
_unpacker.Skip();
}
T t = _unpacker.Unpack <T>();
_unpacker.Dispose();
s.Close();
return(t);
}
public static object Deserialize(Type type, Stream fromStream)
{
try
{
var serializer = MessagePackSerializer.Create(type);
var unpacker = Unpacker.Create(fromStream);
unpacker.Read();
var obj = serializer.UnpackFrom(unpacker);
return obj;
}
catch (Exception ex)
{
return HandleException(ex, type);
}
}
public void Can_serialize_email_dto()
{
using (var ms = new MemoryStream())
{
var serializer = MessagePackSerializer.Get(request.GetType());
serializer.PackTo(Packer.Create(ms), request);
ms.Position = 0;
var unpacker = Unpacker.Create(ms);
unpacker.Read();
var response = serializer.UnpackFrom(unpacker);
Assert.That(response.Equals(request));
}
}
public void TestUnpackTo()
{
var target = this.CreateTarget <Int32[]>(GetSerializationContext());
using (var buffer = new MemoryStream())
{
target.Pack(buffer, new[] { 1, 2 });
buffer.Position = 0;
int[] result = new int[2];
using (var unpacker = Unpacker.Create(buffer, false))
{
unpacker.Read();
target.UnpackTo(unpacker, result);
Assert.That(result, Is.EqualTo(new[] { 1, 2 }));
}
}
}
public ServerMessage(byte[] messageBytes)
{
using (var unpacker = Unpacker.Create(new MemoryStream(messageBytes)))
{
var header = unpacker.ReadItem()?.AsDictionary();
Debug.Assert(header != null);
foreach (var key in header.Keys)
{
var value = header[key];
switch ((TarantoolKey)key.AsInt32())
{
case TarantoolKey.Code:
Code = value.AsInt32();
break;
case TarantoolKey.Sync:
RequestId = value.AsUInt64();
break;
case TarantoolKey.SchemaId:
SchemaId = value.AsInt32();
break;
}
}
var body = unpacker.ReadItem();
var bodyDict = body?.AsDictionary();
if (bodyDict != null)
{
foreach (var key in bodyDict.Keys)
{
var value = bodyDict[key];
switch ((TarantoolKey)key.AsInt32())
{
case TarantoolKey.Data:
Body = value;
break;
case TarantoolKey.Error:
ErrorMessage = value.AsString();
IsError = true;
break;
}
}
}
}
}
private static void InitializeBuffers(ServerRequestContext target)
{
target.ArgumentsBuffer.WriteByte(1);
target.ArgumentsBufferPacker = Packer.Create(target.ArgumentsBuffer, false);
target.ArgumentsBufferUnpacker = Unpacker.Create(target.ArgumentsBuffer, false);
target.ArgumentsCount = 2;
target.UnpackingBuffer = new ByteArraySegmentStream(target.ReceivedData);
target.UnpackedArgumentsCount = 3;
target.RootUnpacker = Unpacker.Create(target.UnpackingBuffer, false);
target.HeaderUnpacker = Unpacker.Create(target.UnpackingBuffer, false);
target.ArgumentsUnpacker = Unpacker.Create(target.UnpackingBuffer, false);
target.SetCompletedSynchronously();
target.MessageId = 123;
target.MessageType = MessageType.Request;
target.MethodName = "Method";
target.NextProcess = _ => true;
}
private static void MakeBufferDirty(ClientResponseContext target)
{
target.SetTransport(new DummyClientTransport());
target.SetReceivingBuffer(new byte[] { 1, 2, 3, 4 });
target.SetBytesTransferred(1);
target.ShiftCurrentReceivingBuffer();
target.ErrorBuffer = new ByteArraySegmentStream(CreateDirtyBytes());
target.ErrorStartAt = 1;
target.HeaderUnpacker = Unpacker.Create(new MemoryStream());
target.MessageId = 1;
target.NextProcess = _ => true;
target.ReceivedData.Add(new ArraySegment <byte>(new byte[] { 1, 2, 3, 4 }));
target.ResultBuffer = new ByteArraySegmentStream(CreateDirtyBytes());
target.ResultStartAt = 2;
target.RenewSessionId();
target.UnpackingBuffer = new ByteArraySegmentStream(CreateDirtyBytes());
}
public static void RunWorker(CancellationTokenSource cancellor, int workerId)
{
var serverThread = new Thread(() =>
{
var nanoSock = new NanomsgSocket(Domain.SP, Protocol.REP);
var nanoListener = new NanomsgListener();
nanoListener.ReceivedMessage += (socketId) =>
{
string input;
using (NanomsgReadStream inStream = nanoSock.ReceiveStream())
using (var unpacker = Unpacker.Create(inStream))
{
if (!unpacker.ReadString(out input))
{
throw new Exception("REQ invalid");
}
Console.WriteLine(input);
}
using (NanomsgWriteStream outStream = nanoSock.CreateSendStream())
using (var packer = Packer.Create(outStream))
{
packer.PackString("Hello " + input);
nanoSock.SendStream(outStream);
}
};
nanoListener.AddSocket(nanoSock);
nanoSock.Connect("tcp://127.0.0.1:" + repPort);
while (!cancellor.IsCancellationRequested)
{
nanoListener.Listen(TimeSpan.FromMilliseconds(250));
}
nanoListener.RemoveSocket(nanoSock);
nanoSock.Dispose();
});
serverThread.Start();
serverThread.Join(TimeSpan.FromMilliseconds(40));
}
public ProtocolMessage DeserializeProtocolMessage(object value)
{
ProtocolMessage message = new ProtocolMessage();
using (MemoryStream stream = new MemoryStream((byte[])value))
{
using (Unpacker unpacker = Unpacker.Create(stream))
{
long fieldCount = 0;
unpacker.ReadMapLength(out fieldCount);
for (int i = 0; i < fieldCount; i++)
{
string fieldName;
unpacker.ReadString(out fieldName);
unpackActions[fieldName](unpacker, message);
}
}
}
return(message);
}
/// <summary>
/// Unpack response message array header.
/// </summary>
/// <param name="context">Context information.</param>
/// <returns>
/// <c>true</c>, if the pipeline is finished;
/// <c>false</c>, the pipeline is interruppted because extra data is needed.
/// </returns>
internal bool UnpackResponseHeader(ClientResponseContext context)
{
Contract.Assert(context != null);
if (context.RootUnpacker == null)
{
context.UnpackingBuffer = new ByteArraySegmentStream(context.ReceivedData);
context.RootUnpacker = Unpacker.Create(context.UnpackingBuffer, false);
context.RenewSessionId();
}
if (!context.ReadFromRootUnpacker())
{
MsgPackRpcClientProtocolsTrace.TraceEvent(MsgPackRpcClientProtocolsTrace.NeedRequestHeader, "Array header is needed. {{ \"SessionID\" : {0} }}", context.SessionId);
return(false);
}
if (!context.RootUnpacker.IsArrayHeader)
{
HandleDeserializationError(context, "Invalid response message stream. Message must be array.", () => context.UnpackingBuffer.ToArray());
return(context.nextProcess(context));
}
if (context.RootUnpacker.ItemsCount != 4)
{
HandleDeserializationError(
context,
string.Format(
CultureInfo.CurrentCulture,
"Invalid response message stream. Message must be valid size array. Actual size is {0}.",
context.RootUnpacker.ItemsCount
),
() => context.UnpackingBuffer.ToArray()
);
return(context.nextProcess(context));
}
context.HeaderUnpacker = context.RootUnpacker.ReadSubtree();
context.nextProcess = UnpackMessageType;
return(context.nextProcess(context));
}
public static object Deserialize(Type type, Stream fromStream)
{
try
{
var msgPackType = GetMsgPackType(type);
type = msgPackType.Type;
var serializer = MessagePackSerializer.Get(type);
var unpacker = Unpacker.Create(fromStream);
unpacker.Read();
var obj = serializer.UnpackFrom(unpacker);
obj = msgPackType.Convert(obj);
return(obj);
}
catch (Exception ex)
{
return(HandleException(ex, type));
}
}
private static HubMessage ParseMessage(Stream input, IInvocationBinder binder)
{
var unpacker = Unpacker.Create(input);
_ = ReadArrayLength(unpacker, "elementCount");
var messageType = ReadInt32(unpacker, "messageType");
switch (messageType)
{
case InvocationMessageType:
return(CreateInvocationMessage(unpacker, binder));
case StreamItemMessageType:
return(CreateStreamItemMessage(unpacker, binder));
case CompletionMessageType:
return(CreateCompletionMessage(unpacker, binder));
default:
throw new FormatException($"Invalid message type: {messageType}.");
}
}
/// <summary>
/// Deserialize object from the <see cref="Stream"/>.
/// </summary>
/// <param name="source"><see cref="MessagePackSerializer"/> object.</param>
/// <param name="stream">Source <see cref="Stream"/>.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="source"/> is <c>null</c>.
/// Or <paramref name="stream"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.Runtime.Serialization.SerializationException">
/// Failed to deserialize from <paramref name="stream"/>.
/// </exception>
public static object Unpack(this MessagePackSerializer source, Stream stream)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
// Unpacker does not have finalizer, so just avoiding unpacker disposing prevents stream closing.
var unpacker = Unpacker.Create(stream);
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
return(source.UnpackFrom(unpacker));
}
public VentMessage Deserialize(byte[] data)
{
var msg = new VentMessage();
using (var stream = new MemoryStream(data))
{
var unpacker = Unpacker.Create(stream);
unpacker.Read();
msg.Source = unpacker.Unpack <string>();
unpacker.Read();
msg.Name = unpacker.Unpack <string>();
unpacker.Read();
msg.MessageType = unpacker.Unpack <string>();
unpacker.Read();
msg.Timestamp = unpacker.Unpack <DateTime>().ToLocalTime();
}
return(msg);
}
public void TestDispatch_MethodNotExists_NoMethodError()
{
using (var server = new RpcServer())
using (var transportManager = new NullServerTransportManager(server))
using (var transport = new NullServerTransport(transportManager))
using (var requestContext = DispatchTestHelper.CreateRequestContext())
using (var argumentsBuffer = new MemoryStream())
using (var waitHandle = new ManualResetEventSlim())
{
var message = Guid.NewGuid().ToString();
using (var argumentsPacker = Packer.Create(argumentsBuffer, false))
{
argumentsPacker.PackArrayHeader(1);
argumentsPacker.Pack(message);
}
argumentsBuffer.Position = 0;
var target = new LocatorBasedDispatcher(server);
MessagePackObject response = MessagePackObject.Nil;
requestContext.MethodName = "Echo:TestServices:1";
requestContext.MessageId = 1;
requestContext.SetTransport(transport);
requestContext.ArgumentsUnpacker = Unpacker.Create(argumentsBuffer);
transport.Sent +=
(sender, e) =>
{
response = Unpacking.UnpackString(e.Context.GetErrorData()).Value;
waitHandle.Set();
};
target.Dispatch(transport, requestContext);
Assert.That(waitHandle.Wait(TimeSpan.FromSeconds(1)));
Assert.That(RpcError.NoMethodError.Identifier == response, "{0} != {1}", message, response);
}
}
private static HubMessage ParseMessage(byte[] input, int startOffset, IInvocationBinder binder)
{
using (var unpacker = Unpacker.Create(input, startOffset))
{
_ = ReadArrayLength(unpacker, "elementCount");
var messageType = ReadInt32(unpacker, "messageType");
switch (messageType)
{
case HubProtocolConstants.InvocationMessageType:
return(CreateInvocationMessage(unpacker, binder));
case HubProtocolConstants.StreamInvocationMessageType:
return(CreateStreamInvocationMessage(unpacker, binder));
case HubProtocolConstants.StreamItemMessageType:
return(CreateStreamItemMessage(unpacker, binder));
case HubProtocolConstants.CompletionMessageType:
return(CreateCompletionMessage(unpacker, binder));
case HubProtocolConstants.CancelInvocationMessageType:
return(CreateCancelInvocationMessage(unpacker));
case HubProtocolConstants.PingMessageType:
return(PingMessage.Instance);
case HubProtocolConstants.CloseMessageType:
return(CreateCloseMessage(unpacker));
default:
// Future protocol changes can add message types, old clients can ignore them
return(null);
}
}
}
private static HubMessage ParseMessage(byte[] input, int startOffset, IInvocationBinder binder)
{
using (var unpacker = Unpacker.Create(input, startOffset))
{
_ = ReadArrayLength(unpacker, "elementCount");
var messageType = ReadInt32(unpacker, "messageType");
switch (messageType)
{
case HubProtocolConstants.InvocationMessageType:
return(CreateInvocationMessage(unpacker, binder));
case HubProtocolConstants.StreamInvocationMessageType:
return(CreateStreamInvocationMessage(unpacker, binder));
case HubProtocolConstants.StreamItemMessageType:
return(CreateStreamItemMessage(unpacker, binder));
case HubProtocolConstants.CompletionMessageType:
return(CreateCompletionMessage(unpacker, binder));
case HubProtocolConstants.CancelInvocationMessageType:
return(CreateCancelInvocationMessage(unpacker));
case HubProtocolConstants.PingMessageType:
return(PingMessage.Instance);
case HubProtocolConstants.CloseMessageType:
return(CreateCloseMessage(unpacker));
default:
throw new FormatException($"Invalid message type: {messageType}.");
}
}
}
protected internal override async Task <TArray> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
{
if (!unpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(unpacker);
}
if (UnpackHelpers.GetItemsCount(unpacker) != 2)
{
SerializationExceptions.ThrowSerializationException("Multidimensional array must be encoded as 2 element array.");
}
using (var wholeUnpacker = unpacker.ReadSubtree())
{
if (!await wholeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
MessagePackExtendedTypeObject metadata;
try
{
metadata = wholeUnpacker.LastReadData.AsMessagePackExtendedTypeObject();
}
catch (InvalidOperationException ex)
{
SerializationExceptions.ThrowSerializationException("Multidimensional array must be encoded as ext type.", ex);
metadata = default(MessagePackExtendedTypeObject); // never reaches
}
if (metadata.TypeCode != this.OwnerContext.ExtTypeCodeMapping[KnownExtTypeName.MultidimensionalArray])
{
SerializationExceptions.ThrowSerializationException(
String.Format(
CultureInfo.CurrentCulture,
"Multidimensional array must be encoded as ext type 0x{0:X2}.",
this.OwnerContext.ExtTypeCodeMapping[KnownExtTypeName.MultidimensionalArray]
)
);
}
Tuple <int[], int[]> lengthsAndLowerBounds;
using (var arrayMetadata = new MemoryStream(metadata.Body))
using (var metadataUnpacker = Unpacker.Create(arrayMetadata, false))
{
if (!metadataUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!metadataUnpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(unpacker);
}
if (UnpackHelpers.GetItemsCount(metadataUnpacker) != 2)
{
SerializationExceptions.ThrowSerializationException("Multidimensional metadata array must be encoded as 2 element array.");
}
lengthsAndLowerBounds = await this.ReadArrayMetadataAsync(metadataUnpacker, cancellationToken).ConfigureAwait(false);
}
if (!await wholeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!wholeUnpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(unpacker);
}
using (var arrayUnpacker = wholeUnpacker.ReadSubtree())
{
var result =
Array.CreateInstance(typeof(TItem), lengthsAndLowerBounds.Item1, lengthsAndLowerBounds.Item2);
var totalLength = UnpackHelpers.GetItemsCount(arrayUnpacker);
if (totalLength > 0)
{
ForEach(
result,
totalLength,
lengthsAndLowerBounds.Item2,
lengthsAndLowerBounds.Item1,
async indices =>
{
// ReSharper disable AccessToDisposedClosure
if (!await arrayUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
result.SetValue(
await this._itemSerializer.UnpackFromAsync(arrayUnpacker, cancellationToken).ConfigureAwait(false),
indices
);
// ReSharper restore AccessToDisposedClosure
}
);
}
return(( TArray )( object )result);
}
}
}
public MessagePackReader(Stream stream)
{
Unpacker unpacker = Unpacker.Create(stream);
mState = new State(this, unpacker, null);
}
protected internal override object UnpackFromCore(Unpacker unpacker)
#endif // !UNITY
{
if (!unpacker.IsArrayHeader)
{
throw SerializationExceptions.NewIsNotArrayHeader();
}
if (UnpackHelpers.GetItemsCount(unpacker) != 2)
{
throw new SerializationException("Multidimensional array must be encoded as 2 element array.");
}
using (var wholeUnpacker = unpacker.ReadSubtree())
{
if (!wholeUnpacker.Read())
{
throw SerializationExceptions.NewUnexpectedEndOfStream();
}
MessagePackExtendedTypeObject metadata;
try
{
metadata = wholeUnpacker.LastReadData.AsMessagePackExtendedTypeObject();
}
catch (InvalidOperationException ex)
{
throw new SerializationException("Multidimensional array must be encoded as ext type.", ex);
}
if (metadata.TypeCode != MultidimensionalArray)
{
throw new SerializationException(
String.Format(
CultureInfo.CurrentCulture,
"Multidimensional array must be encoded as ext type {0}.",
MultidimensionalArray
)
);
}
int[] lengths, lowerBounds;
using (var arrayMetadata = new MemoryStream(metadata.Body))
using (var metadataUnpacker = Unpacker.Create(arrayMetadata))
{
if (!metadataUnpacker.Read())
{
throw SerializationExceptions.NewUnexpectedEndOfStream();
}
if (!metadataUnpacker.IsArrayHeader)
{
throw SerializationExceptions.NewIsNotArrayHeader();
}
if (UnpackHelpers.GetItemsCount(metadataUnpacker) != 2)
{
throw new SerializationException("Multidimensional metadata array must be encoded as 2 element array.");
}
this.ReadArrayMetadata(metadataUnpacker, out lengths, out lowerBounds);
}
#if SILVERLIGHT
// Simulate lowerbounds because Array.Initialize() in Silverlight does not support lowerbounds.
for (var i = 0; i < lowerBounds.Length; i++)
{
lengths[i] += lowerBounds[i];
}
#endif // SILVERLIGHT
if (!wholeUnpacker.Read())
{
throw SerializationExceptions.NewUnexpectedEndOfStream();
}
if (!wholeUnpacker.IsArrayHeader)
{
throw SerializationExceptions.NewIsNotArrayHeader();
}
using (var arrayUnpacker = wholeUnpacker.ReadSubtree())
{
var result =
Array.CreateInstance(
#if !UNITY
typeof(TItem),
#else
this._itemType,
#endif // !UNITY
#if !SILVERLIGHT
lengths,
lowerBounds
#else
lengths
#endif // !SILVERLIGHT
);
var totalLength = UnpackHelpers.GetItemsCount(arrayUnpacker);
if (totalLength > 0)
{
ForEach(
result,
totalLength,
lowerBounds,
lengths,
indices =>
{
// ReSharper disable AccessToDisposedClosure
if (!arrayUnpacker.Read())
{
throw SerializationExceptions.NewUnexpectedEndOfStream();
}
result.SetValue(
this._itemSerializer.UnpackFrom(arrayUnpacker),
indices
);
// ReSharper restore AccessToDisposedClosure
}
);
}
#if !UNITY
return(( TArray )( object )result);
#else
return(result);
#endif // !UNITY
}
}
}
