コード例 #1
0
        public static TransportMessage ReadTransportMessage(this BinaryReader reader)
        {
            var metadata = new VolatileTransportMetadata();

            var signal = BitConverter.ToInt32(reader.ReadBytes(4), 0);

            if (signal != 0)
            {
                throw new Exception("Message received with signal code " + signal.ToString());
            }

            var frameCount = BitConverter.ToInt32(reader.ReadBytes(4), 0);

            for (var a = 0; a < frameCount; a++)
            {
                var idLength  = BitConverter.ToInt32(reader.ReadBytes(4), 0);
                var encodedId = reader.ReadBytes(idLength);

                var dataLength = BitConverter.ToInt32(reader.ReadBytes(4), 0);
                var data       = reader.ReadBytes(dataLength);

                metadata.Frames.Add(new VolatileTransportMetadataFrame(Encoding.UTF8.GetString(encodedId), data));
            }

            var payloadLength = BitConverter.ToInt32(reader.ReadBytes(4), 0);
            var payload       = reader.ReadBytes(payloadLength);

            return(new TransportMessage(payload, metadata));
        }
コード例 #2
0
        public override async Task WriteData(ITransport transport, string messageId, ITransportMetadata metadata, Action <IProtocolWriter> handler)
        {
            using (var buffer = new MemoryStream())
            {
                var writer = new MessagePackProtocolWriter(buffer);
                handler(writer);

                buffer.Position = 0;
                var data = buffer.ToArray();
                await transport.Send(messageId, new TransportMessage(data, VolatileTransportMetadata.FromMetadata(metadata)));
            }
        }
コード例 #3
0
        public override async Task <Func <Func <IProtocolReader, ITransportMetadata, TResult>, Task <TResult> > > WriteAndReadData <TResult>(ITransport transport, ITransportMetadata metadata, Action <IProtocolWriter> handler)
        {
            Func <Task <TransportMessage> > receiveHandler;

            using (var buffer = new MemoryStream())
            {
                var writer = new MessagePackProtocolWriter(buffer);
                handler(writer);

                buffer.Position = 0;
                var data = buffer.ToArray();
                receiveHandler = await transport.SendAndReceive(new TransportMessage(data, VolatileTransportMetadata.FromMetadata(metadata)));
            }

            return(new Func <Func <IProtocolReader, ITransportMetadata, TResult>, Task <TResult> >(async(readHandler) => {
                var receivedData = await receiveHandler();

                var buffer = new MemoryStream(receivedData.Payload);
                var reader = new MessagePackProtocolReader(buffer);

                return readHandler(reader, receivedData.Metadata);
            }));
        }