Esempio n. 1
0
        public async Task <string> GetFilenameAsync(string request)
        {
            var client = await _lookupDispatcher.TakeAsync();

            var filename     = Path.GetRandomFileName();
            var binaryWriter = new BinaryWriter(File.Open(filename, FileMode.OpenOrCreate));

            var ct  = new CancellationTokenSource(_timeoutMs);
            var res = new TaskCompletionSource <string>();

            ct.Token.Register(() => res.TrySetCanceled(), false);

            void SocketClientOnMessageReceived(object sender, SocketMessageEventArgs args)
            {
                // check for errors
                if (args.Message[0] == IQFeedDefault.PrototolErrorCharacter && args.Message[1] == IQFeedDefault.ProtocolDelimiterCharacter)
                {
                    var errorMessage = Encoding.ASCII.GetString(args.Message, 0, args.Count);
                    res.TrySetException(_errorMessageHandler.GetException(errorMessage));
                    return;
                }

                binaryWriter.Write(args.Message, 0, args.Count);

                // check if the message end
                if (args.Message.EndsWith(args.Count, _endOfMsgBytes))
                {
                    res.TrySetResult(filename);
                }
            }

            client.MessageReceived += SocketClientOnMessageReceived;
            client.Send(request);

            await res.Task.ContinueWith(x =>
            {
                binaryWriter.Close();
                client.MessageReceived -= SocketClientOnMessageReceived;
                _lookupDispatcher.Add(client);
                ct.Dispose();
                if (res.Task.IsFaulted)
                {
                    File.Delete(filename);
                }
            }, TaskContinuationOptions.None).ConfigureAwait(false);

            return(await res.Task.ConfigureAwait(false));
        }
        protected async Task <IEnumerable <T> > GetMessagesAsync <T>(string request, Func <byte[], int, MessageContainer <T> > messageHandler)
        {
            var client = await _lookupDispatcher.TakeAsync();

            var messages = new List <T>();
            var ct       = new CancellationTokenSource(_timeoutMs);
            var res      = new TaskCompletionSource <IEnumerable <T> >();

            ct.Token.Register(() => res.TrySetCanceled(), false);

            void SocketClientOnMessageReceived(object sender, SocketMessageEventArgs args)
            {
                var container = messageHandler(args.Message, args.Count);

                if (container.ErrorMessage != null)
                {
                    res.TrySetException(_errorMessageHandler.GetException(container.ErrorMessage));
                    return;
                }

                messages.AddRange(container.Messages);

                if (container.End)
                {
                    res.TrySetResult(messages);
                }
            }

            client.MessageReceived += SocketClientOnMessageReceived;
            client.Send(request);

            await res.Task.ContinueWith(x =>
            {
                client.MessageReceived -= SocketClientOnMessageReceived;
                _lookupDispatcher.Add(client);
                ct.Dispose();
            }, TaskContinuationOptions.None).ConfigureAwait(false);

            return(await res.Task.ConfigureAwait(false));
        }