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