System.Threading.Tasks.TaskCompletionSource.SetResult(Message)

Here are the examples of the csharp api System.Threading.Tasks.TaskCompletionSource.SetResult(Message) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

4 Examples 7

19 Source : TransportTest.cs
with GNU Lesser General Public License v2.1
from planetarium

[SkippableFact(Timeout = Timeout, Skip = "Target method is broken.")]
        public async Task SendMessageAsync()
        {
            ITransport transportA = CreateTransport();
            ITransport transportB = CreateTransport();

            TaskCompletionSource<Message> tcs = new TaskCompletionSource<Message>();

            transportB.ProcessMessageHandler.Register(async message =>
            {
                tcs.SetResult(message);
                await Task.Yield();
            });

            try
            {
                await InitializeAsync(transportA);
                await InitializeAsync(transportB);

                replacedert.True(transportA.Running);
                replacedert.True(transportB.Running);

                await transportA.SendMessageAsync(
                    (BoundPeer)transportB.AsPeer,
                    new Ping(),
                    CancellationToken.None);

                Message message = await tcs.Task;

                replacedert.IsType<Ping>(message);
            }
            finally
            {
                transportA.Dispose();
                transportB.Dispose();
            }
        }

19 Source : TransportTest.cs
with GNU Lesser General Public License v2.1
from planetarium

[SkippableFact(Timeout = Timeout)]
        public async Task BroadcastMessage()
        {
            var address = new PrivateKey().ToAddress();
            ITransport transportA = null;
            ITransport transportB = CreateTransport(
                privateKey: TestUtils.GeneratePrivateKeyOfBucketIndex(address, 0));
            ITransport transportC = CreateTransport(
                privateKey: TestUtils.GeneratePrivateKeyOfBucketIndex(address, 1));
            ITransport transportD = CreateTransport(
                privateKey: TestUtils.GeneratePrivateKeyOfBucketIndex(address, 2));

            var tcsB = new TaskCompletionSource<Message>();
            var tcsC = new TaskCompletionSource<Message>();
            var tcsD = new TaskCompletionSource<Message>();

            transportB.ProcessMessageHandler.Register(MessageHandler(tcsB));
            transportC.ProcessMessageHandler.Register(MessageHandler(tcsC));
            transportD.ProcessMessageHandler.Register(MessageHandler(tcsD));

            Func<Message, Task> MessageHandler(TaskCompletionSource<Message> tcs)
            {
                return async message =>
                {
                    if (message is Ping)
                    {
                        tcs.SetResult(message);
                    }

                    await Task.Yield();
                };
            }

            try
            {
                await InitializeAsync(transportB);
                await InitializeAsync(transportC);
                await InitializeAsync(transportD);

                var table = new RoutingTable(address, bucketSize: 1);
                table.AddPeer(transportB.AsPeer as BoundPeer);
                table.AddPeer(transportC.AsPeer as BoundPeer);
                table.AddPeer(transportD.AsPeer as BoundPeer);

                transportA = CreateTransport(table);
                await InitializeAsync(transportA);

                transportA.BroadcastMessage(transportD.AsPeer.Address, new Ping());

                await Task.WhenAll(tcsB.Task, tcsC.Task);

                replacedert.IsType<Ping>(tcsB.Task.Result);
                replacedert.IsType<Ping>(tcsC.Task.Result);
                replacedert.False(tcsD.Task.IsCompleted);

                tcsD.SetCanceled();
            }
            finally
            {
                transportA?.Dispose();
                transportB.Dispose();
                transportC.Dispose();
                transportD.Dispose();
            }
        }

19 Source : DotClient.cs
with MIT License
from richardschneider

void ReadResponses(Stream stream)
        {
            var reader = new WireReader(stream);
            while (stream.CanRead)
            {
                try
                {
                    var length = reader.ReadUInt16();
                    if (length < Message.MinLength)
                        throw new InvalidDataException("DNS response is too small.");
                    if (length > Message.MaxLength)
                       throw new InvalidDataException("DNS response exceeded max length.");
                    Message response;
                    var packet = reader.ReadBytes(length);
                    try
                    {
                        // TODO: Should work, but doesn't
                        //var response = (Message)new Message().Read(reader);
                        response = (Message)new Message().Read(packet);
                    }
                    catch (Exception e)
                    {
                        log.Error($"Failed to read response {Convert.ToBase64String(packet)}", e);
                        continue;
                    }

                    // Find matching request.
                    if (log.IsDebugEnabled)
                        log.Debug($"Got response #{response.Id} {response.Status}");
                    if (log.IsTraceEnabled)
                        log.Trace(response);
                    if (!OutstandingRequests.TryGetValue(response.Id, out var task))
                    {
                        log.Warn("DNS response is missing a matching request ID.");
                        continue;
                    }

                    // Continue the request.
                    task.SetResult(response);
                }
                catch (EndOfStreamException)
                {
                    stream.Dispose();
                }
                catch (Exception e)
                {
#if NETSTANDARD14
                    if (stream.CanRead)
#else
                    if (stream.CanRead && !(e.InnerException is ThreadAbortException))
#endif
                    {
                            log.Error(e);
                    }
                    stream.Dispose();
                }
            }

            // Cancel any outstanding queries.
            foreach (var task in OutstandingRequests.Values)
            {
                task.SetCanceled();
            }
        }

19 Source : MulticastService.cs
with MIT License
from richardschneider

public Task<Message> ResolveAsync(Message request, CancellationToken cancel = default(CancellationToken))
        {
            var tsc = new TaskCompletionSource<Message>();

            void checkResponse(object s, MessageEventArgs e)
            {
                var response = e.Message;
                if (request.Questions.All(q => response.Answers.Any(a => a.Name == q.Name)))
                {
                    AnswerReceived -= checkResponse;
                    tsc.SetResult(response);
                }
            }

            cancel.Register(() =>
            {
                AnswerReceived -= checkResponse;
                tsc.TrySetCanceled();
            });

            AnswerReceived += checkResponse;
            SendQuery(request);

            return tsc.Task;
        }