/// <summary>
/// 使用专用的Confirm模式，每Publish消息一次就确认一次
/// </summary>
/// <param name="publishActions">要发布消息的具体方法集，每个方法只有一次Publish的调用</param>
/// <returns>每个发布方法按序生成(从1开始)的发布成功标识</returns>
public SortedDictionary <ulong, bool> PublishConfirm(params Action <IMQPublisher>[] publishActions)
{
var confirmChannel = con.CreateModel();
IMQPublisher confirmPublisher = new RabbitMQPublisher(() => confirmChannel, setExistsQueue, ManagerInstance.QueueDeclare);
confirmChannel.ConfirmSelect();
SortedDictionary <ulong, bool> dicValues = new SortedDictionary <ulong, bool>();
try
{
foreach (var action in publishActions)
{
//当Channe关闭时直接退出
if (confirmChannel.IsClosed)
{
break;
}
var seqNo = confirmChannel.NextPublishSeqNo;
if (!dicValues.ContainsKey(seqNo))
{
dicValues.Add(seqNo, false);
}
try
{
action.Invoke(confirmPublisher);
dicValues[dicValues.Keys.Max()] = confirmChannel.WaitForConfirms();
}
catch (AlreadyClosedException)
{
break;
}
catch (OperationInterruptedException)
{
break;
}
catch (Exception ex)
{
Console.WriteLine("PublishConfirm方法使用Confirm模式发送消息时发生异常:{0},StackTrace:{1}", ex.Message, ex.StackTrace);
}
}
}
finally
{
confirmPublisher.Dispose();
}
return(dicValues);
}
/// <summary>
/// 使用专用的Confirm模式，Publish消息后通过异步的方式对消息进行确认
/// </summary>
/// <param name="ackHandler">消息确认成功时的事件处理方法</param>
/// <param name="nackHandler">消息确认失败时的事件处理方法</param>
/// <param name="publishActions">要发布消息的具体方法集，每个方法只有一次Publish的调用</param>
/// <returns>发送消息的专用生产端，可获取已发送的序号，关闭通道等</returns>
public IMQPublisher PublishConfirmAsync(Action <PublishAckArgs> ackHandler, Action <PublishNAckArgs> nackHandler, params Action <IMQPublisher>[] publishActions)
{
var confirmChannel = con.CreateModel();
IMQPublisher confirmPublisher = new RabbitMQPublisher(() => confirmChannel, setExistsQueue, ManagerInstance.QueueDeclare);
confirmChannel.ConfirmSelect();
//确认接收
confirmChannel.BasicAcks += (sender, e) =>
{
ackHandler(new PublishAckArgs(confirmChannel.NextPublishSeqNo - 1, e.DeliveryTag, e.Multiple));
};
//未确认接收
confirmChannel.BasicNacks += (sender, e) =>
{
nackHandler(new PublishNAckArgs(confirmChannel.NextPublishSeqNo - 1, e.DeliveryTag, e.Multiple, e.Requeue));
};
try
{
foreach (var action in publishActions)
{
action.Invoke(confirmPublisher);
}
}
catch (AlreadyClosedException)
{
}
catch (OperationInterruptedException)
{
}
catch (System.IO.IOException)
{
}
catch (Exception)
{
//publishActions内的异常，这时还未调用Publish故计算器不会预加1
}
return(confirmPublisher);
}
/// <summary>
/// 使用专用的Confirm模式，多次Publish消息后。全部批量确认
/// </summary>
/// <param name="publishActions">要发布消息的具体方法集，每个方法只有一次Publish的调用</param>
/// <returns>已发布成功的方法序号(从1开始)，以及有异常时的相应描述</returns>
public Tuple <ulong, Exception> PublishConfirms(params Action <IMQPublisher>[] publishActions)
{
var confirmChannel = con.CreateModel();
IMQPublisher confirmPublisher = new RabbitMQPublisher(() => confirmChannel, setExistsQueue, ManagerInstance.QueueDeclare);
confirmChannel.ConfirmSelect();
Tuple <ulong, Exception> rtnValue;
try
{
foreach (var action in publishActions)
{
action.Invoke(confirmPublisher);
}
confirmChannel.WaitForConfirmsOrDie();
rtnValue = new Tuple <ulong, Exception>(confirmChannel.NextPublishSeqNo - 1, null);
}
catch (AlreadyClosedException ex)
{
rtnValue = new Tuple <ulong, Exception>(Math.Max(0, confirmChannel.NextPublishSeqNo - 2), ex);
}
catch (OperationInterruptedException ex)
{
rtnValue = new Tuple <ulong, Exception>(Math.Max(0, confirmChannel.NextPublishSeqNo - 2), ex);
}
catch (System.IO.IOException ex)
{
rtnValue = new Tuple <ulong, Exception>(Math.Max(0, confirmChannel.NextPublishSeqNo - 2), ex);
}
catch (Exception ex)
{
//publishActions内的异常，这时还未调用Publish故计算器不会预加1
rtnValue = new Tuple <ulong, Exception>(confirmChannel.NextPublishSeqNo - 1, ex);
}
finally
{
confirmPublisher.Dispose();
}
return(rtnValue);
}
