/// <inheritdoc />
        public async Task ReceiveMessageAsync(MessageWrapper message)
        {
            //assume that message contains 'TaskDescription'
            var description = message.CreateMessage <TaskDescription>();

            if (description == null)
            {
                return;                      //wrong message
            }
            var queue = await TimeoutRetryHelper.Execute((token, state) => StateManager.GetOrAddAsync <IReliableQueue <MessageWrapper> >(_queueName));

            await TimeoutRetryHelper
            .ExecuteInTransaction(StateManager, (tran, token, state) => queue.EnqueueAsync(tran, message))
            .ConfigureAwait(false);
        }
        /// <inheritdoc/>
        public Task ProccessMessageAsync(MessageWrapper messageWrapper, Dictionary <Type, Func <object, Task> > handlers)
        {
            var messageType = Assembly.Load(messageWrapper.Assembly).GetType(messageWrapper.MessageType, true);

            while (messageType != null)
            {
                if (handlers.TryGetValue(messageType, out var handler))
                {
                    return(handler(messageWrapper.CreateMessage()));
                }
                messageType = messageType.BaseType;
            }

            return(Task.FromResult(true));
        }
        /// <summary>
        /// Deserializes the provided <paramref name="messageWrapper"/> Payload into an instance of type <typeparam name="TResult"></typeparam>
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <returns></returns>
        public static TResult Deserialize <TResult>(this StatelessService service, MessageWrapper messageWrapper)
        {
            if (messageWrapper == null)
            {
                throw new ArgumentNullException(nameof(messageWrapper));
            }
            if (string.IsNullOrWhiteSpace(messageWrapper.Payload))
            {
                throw new ArgumentNullException(nameof(messageWrapper.Payload));
            }

            var payload = messageWrapper.CreateMessage <TResult>();

            return(payload);
        }
        /// <inheritdoc />
        public Task ProcessMessageAsync(MessageWrapper messageWrapper)
        {
            var message     = messageWrapper.CreateMessage();
            var messageType = message.GetType();

            while (messageType != null)
            {
                if (Handlers.TryGetValue(messageType, out var handler))
                {
                    return(handler(message));
                }
                messageType = messageType.BaseType;
            }

            return(Task.FromResult(true));
        }
Exemple #5
0
 /// <summary>
 /// Deserializes the provided <paramref name="messageWrapper"/> Payload into an intance of type <typeparam name="TResult"></typeparam>
 /// </summary>
 /// <typeparam name="TResult"></typeparam>
 /// <returns></returns>
 public static TResult Deserialize <TResult>(this ActorBase actor, MessageWrapper messageWrapper)
 {
     return(messageWrapper.CreateMessage <TResult>());
 }