예제 #1
0
        /// <summary>
        /// 异步监听并开始消费消息
        /// </summary>
        /// <param name="listenOptions"></param>
        /// <param name="action"></param>
        /// <returns></returns>
        public async Task <ListenResult> ListenAsync(ListenOptions listenOptions, Action <RecieveResult> action = null)
        {
            ListenResult result = new ListenResult();

            new Task(() =>
            {
                ListenInterval(listenOptions, action, result);
            }).Start();
            return(await Task.FromResult(result));
        }
예제 #2
0
        /// <summary>
        /// 阻塞当前线程同步监听并开始消费消息
        /// </summary>
        /// <param name="listenOptions"></param>
        /// <param name="action"></param>
        /// <param name="cancellationToken"></param>
        public void Listen(ListenOptions listenOptions, Action <RecieveResult> action = null, CancellationToken cancellationToken = default)
        {
            ListenResult result = new ListenResult();

            cancellationToken.Register(() =>
            {
                result.Stop();
            });
            ListenInterval(listenOptions, action, result);
        }
예제 #3
0
        /// <summary>
        /// 开始监听消费消息
        /// </summary>
        /// <param name="listenOptions"></param>
        /// <param name="action"></param>
        /// <param name="listenResult"></param>
        private void ListenInterval(ListenOptions listenOptions, Action <RecieveResult> action, ListenResult listenResult)
        {
            if (listenResult.Stoped)
            {
                return;
            }

            var connection   = GetConnection(listenOptions);
            var registration = listenResult.Token.Register(() =>
            {
                Tracer.Info("Stopping... Listen");
                connection.Dispose();
            });

            if (!connection.IsStarted)
            {
                connection.Start();
            }
            ISession         session  = connection.CreateSession(listenOptions.AutoAcknowledge ? AcknowledgementMode.AutoAcknowledge : AcknowledgementMode.ClientAcknowledge);
            IMessageConsumer consumer = GetMessageConsumer(session, listenOptions);

            Tracer.Info("Listen Interval:Recieving...");
            if (listenOptions.PrefetchCount <= 0)
            {
                Task.Run(() =>
                {
                    while (true)
                    {
                        if (listenResult.Stoped)
                        {
                            break;
                        }
                        try
                        {
                            IMessage message = consumer.Receive();
                            OnMessage(message, action);
                        }
                        catch (Exception ex)
                        {
                            while (ex != null)
                            {
                                Tracer.Error($"{ex.GetType().FullName}:{ex.Message}{Environment.NewLine}{ex.StackTrace}");
                                ex = ex.InnerException;
                            }
                        }
                    }
                });
            }
            else
            {
                consumer.Listener += new MessageListener(message =>
                {
                    OnMessage(message, action);
                });
            }

            /// <summary>
            /// 消费消息
            /// </summary>
            /// <param name="message"></param>
            /// <param name="onMessage"></param>
            void OnMessage(IMessage message, Action <RecieveResult> onMessage)
            {
                RecieveResult recieveResult = null;

                if (message is ITextMessage textMessage)
                {
                    recieveResult = new RecieveResult(textMessage);
                }
                if (recieveResult != null)
                {
                    onMessage?.Invoke(recieveResult);
                    if (!recieveResult.IsCommitted && !listenOptions.AutoAcknowledge && listenOptions.RecoverWhenNotAcknowledge)
                    {
                        //通知mq进行重发  最多重发六次
                        session.Recover();
                    }
                }
            }
        }