Ejemplo n.º 1
0
        internal async Task Run()
        {
            var processedCount = 0;

            while (processedCount < _batchCount)
            {
                MailboxMessage processingMessage = null;
                try
                {
                    if (MessageQueue.TryDequeue(out processingMessage))
                    {
                        processedCount++;
                        await processingMessage.Task().ConfigureAwait(false);

                        processingMessage.TaskCompletionSource
                        .TrySetResult(null);
                    }
                    else
                    {
                        break;
                    }
                }
                catch (Exception ex)
                {
                    processingMessage?.TaskCompletionSource
                    .TrySetException(ex);
                }
            }

            ExitHandlingMessage();
        }
Ejemplo n.º 2
0
 public Task Process(string key, Func <Task> process, TaskCompletionSource <object> taskCompletionSource = null)
 {
     if (string.IsNullOrWhiteSpace(key))
     {
         return(process());
     }
     else
     {
         var mailboxMessage = new MailboxMessage(key, process, taskCompletionSource);
         _mailboxProcessorCommands.Add(new ProcessMessageCommand(mailboxMessage));
         return(mailboxMessage.TaskCompletionSource.Task);
     }
 }
Ejemplo n.º 3
0
 public Task <T> Process <T>(string key, Func <Task <T> > process, TaskCompletionSource <object> taskCompletionSource = null)
 {
     if (string.IsNullOrWhiteSpace(key))
     {
         return(process());
     }
     else
     {
         var mailboxMessage = new MailboxMessage(key, process, taskCompletionSource);
         _mailboxProcessorCommands.Add(new ProcessMessageCommand(mailboxMessage));
         return(mailboxMessage.TaskCompletionSource.Task
                .ContinueWith(t =>
         {
             if (t.IsFaulted)
             {
                 throw new AggregateException(t.Exception);
             }
             return (T)t.Result;
         }));
     }
 }
Ejemplo n.º 4
0
        internal async Task Run()
        {
            var processedCount = 0;

            while (processedCount < _batchCount)
            {
                MailboxMessage processingMessage = null;
                try
                {
                    if (MessageQueue.TryDequeue(out processingMessage))
                    {
                        processedCount++;
                        var task = await Task.Run <Task>(() => processingMessage.Task())
                                   .ConfigureAwait(false);

                        await task.ConfigureAwait(false);

                        object returnValue = null;
                        if (processingMessage.HasReturnValue)
                        {
                            returnValue = ((dynamic)task).Result;
                        }
                        processingMessage.TaskCompletionSource
                        .TrySetResult(returnValue);
                    }
                    else
                    {
                        break;
                    }
                }
                catch (Exception ex)
                {
                    processingMessage?.TaskCompletionSource
                    .TrySetException(ex);
                }
            }

            ExitHandlingMessage();
        }
Ejemplo n.º 5
0
 public void EnqueueMessage(MailboxMessage message)
 {
     MessageQueue.Enqueue(message);
 }
Ejemplo n.º 6
0
 public ProcessMessageCommand(MailboxMessage message)
 {
     Message = message;
 }