using Newtonsoft.Json.Linq;
|
using RabbitMQ.Client;
|
using RabbitMQ.Client.Events;
|
using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
namespace CommonUtil.RabbitMQ
|
{
|
/// <summary>
|
///
|
/// </summary>
|
public class MQClientFullChannel : IDisposable
|
{
|
|
#region 变量
|
|
/// <summary>
|
/// 接收
|
/// </summary>
|
public IModel channelReceive { get; internal set; }
|
|
/// <summary>
|
/// 链接
|
/// </summary>
|
public IConnection connectionReceive { get; internal set; }
|
|
/// <summary>
|
/// 发送对象
|
/// </summary>
|
public string queueName { get; set; }
|
|
/// <summary>
|
/// 日志文件名
|
/// </summary>
|
public string logName { get; set; }
|
|
/// <summary>
|
/// >0 表示允许重连，等待多少毫秒
|
/// </summary>
|
public int reConnectTime { get; set; }
|
|
|
#endregion
|
|
#region 构造函数
|
|
/// <summary>
|
/// 空构造函数
|
/// </summary>
|
public MQClientFullChannel()
|
{
|
queueName = "";
|
logName = "MQ日志";
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="qname">需要接收或发送的qname</param>
|
public MQClientFullChannel(string qname)
|
{
|
queueName = qname;
|
logName = "MQ日志";
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="qname">需要接收或发送的qname</param>
|
/// <param name="lname">日志文件</param>
|
public MQClientFullChannel(string qname, string lname)
|
{
|
queueName = qname;
|
logName = lname;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
public void Dispose()
|
{
|
if (connectionReceive != null)
|
{
|
connectionReceive.Dispose();
|
}
|
|
if (channelReceive != null)
|
{
|
channelReceive.Dispose();
|
}
|
}
|
|
#endregion
|
|
#region 发送消息 静态方法
|
|
/// <summary>
|
/// 发送消息
|
/// </summary>
|
/// <param name="param"></param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <returns></returns>
|
public static string SendMessageStatic(MQClientParam param, string mqname, string message)
|
{
|
using (MQClientFullChannel mQClientFullChannel = new MQClientFullChannel(mqname))
|
{
|
string ret = mQClientFullChannel.SendMessage(param, message);
|
return ret;
|
}
|
|
}
|
|
/// <summary>
|
/// 发送消息
|
/// </summary>
|
/// <param name="mode"></param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <returns></returns>
|
public static string SendMessageStatic(int mode, string mqname, string message)
|
{
|
using (MQClientFullChannel mQClientFullChannel = new MQClientFullChannel(mqname))
|
{
|
string ret = mQClientFullChannel.SendMessage(mode, message);
|
return ret;
|
}
|
}
|
|
#endregion
|
|
#region 发送消息
|
|
/// <summary>
|
/// 添加即时消息
|
/// </summary>
|
/// <param name="param"></param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <returns></returns>
|
public string SendMessage(MQClientParam param, string mqname, string message)
|
{
|
try
|
{
|
|
ConnectionFactory factory = new ConnectionFactory();
|
factory.HostName = param.HostName;
|
factory.UserName = param.UserName;
|
factory.Password = param.Password;
|
factory.Port = param.Port;
|
factory.VirtualHost = param.VirtualHost;
|
using (var connection = factory.CreateConnection())
|
{
|
using (var channel = connection.CreateModel())
|
{
|
channel.QueueDeclare(mqname, true, false, false, null);
|
var properties = channel.CreateBasicProperties();
|
properties.DeliveryMode = 2;
|
properties.Persistent = true;
|
var body = Encoding.UTF8.GetBytes(message);
|
channel.BasicPublish("", mqname, properties, body);
|
}
|
}
|
return "ok";
|
}
|
catch (Exception ee)
|
{
|
// 写入日志
|
Task.Run(() =>
|
{
|
LogUtil.Error(ee.Message.ToString(), logName);
|
});
|
return ee.Message.ToString();
|
}
|
}
|
|
/// <summary>
|
/// 添加即时消息
|
/// </summary>
|
/// <param name="param"></param>
|
/// <param name="message"></param>
|
/// <returns></returns>
|
public string SendMessage(MQClientParam param, string message)
|
{
|
string mqname = queueName;
|
if (string.IsNullOrWhiteSpace(mqname))
|
{
|
return "传入的参数不正确!";
|
}
|
return SendMessage(param, mqname, message);
|
}
|
|
/// <summary>
|
/// 根据AppSetting.Json中的内容发送信息
|
/// </summary>
|
/// <param name="mode"> 0-独立 1-集群</param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <returns></returns>
|
public string SendMessage(int mode, string mqname, string message)
|
{
|
MQClientParam param;
|
string ret = GetParam(mode, out param);
|
if (ret != "ok") return ret;
|
return SendMessage(param, mqname, message);
|
}
|
|
/// <summary>
|
/// 根据AppSetting.Json中的内容发送信息
|
/// </summary>
|
/// <param name="mode">0-独立 1-集群</param>
|
/// <param name="message"></param>
|
/// <returns></returns>
|
public string SendMessage(int mode, string message)
|
{
|
string mqname = queueName;
|
if (string.IsNullOrWhiteSpace(mqname))
|
{
|
return "传入的参数不正确!";
|
}
|
return SendMessage(mode, mqname, message);
|
}
|
/// <summary>
|
/// 发送定时消息
|
/// </summary>
|
/// <param name="mode"></param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <param name="sendTime"></param>
|
/// <returns></returns>
|
public static string SendDelayMessageStatic(int mode, string mqname, string message, DateTime sendTime)
|
{
|
using (MQClientFullChannel mQClientFullChannel = new MQClientFullChannel())
|
{
|
string ret = mQClientFullChannel.SendDelayMessage(mode, mqname, message, sendTime);
|
return ret;
|
}
|
}
|
|
/// <summary>
|
/// 添加延时消息
|
/// </summary>
|
/// <param name="param"></param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <param name="sendtime"></param>
|
/// <returns></returns>
|
public string SendDelayMessage(MQClientParam param, string mqname, string message, DateTime sendtime)
|
{
|
try
|
{
|
if (sendtime <= DateTime.Now)
|
{
|
return SendMessage(param, queueName, message);
|
}
|
else
|
{
|
TimeSpan ts = sendtime - DateTime.Now;
|
long ttl = long.Parse(ts.TotalMilliseconds.ToString("f0"));
|
ConnectionFactory factory = new ConnectionFactory();
|
factory.HostName = param.HostName;
|
factory.UserName = param.UserName;
|
factory.Password = param.Password;
|
factory.Port = param.Port;
|
factory.VirtualHost = param.VirtualHost;
|
using (var connection = factory.CreateConnection())
|
{
|
using (var channel = connection.CreateModel())
|
{
|
//string fqname = Enum.GetName(queueName.GetType(), queueName);
|
Dictionary<string, object> dic = new Dictionary<string, object>();
|
dic.Add("x-expires", ttl + 300000); //队列中所有消息都有相同的过期时间
|
dic.Add("x-message-ttl", ttl);//队列上消息过期时间，应小于队列过期时间
|
dic.Add("x-dead-letter-exchange", "exchange-direct");//过期消息转向路由
|
dic.Add("x-dead-letter-routing-key", mqname);//过期消息转向路由相匹配routingkey
|
|
string qname = "duomaitime" + Guid.NewGuid().ToString();
|
channel.ExchangeDeclare(exchange: "exchange-direct", type: "direct");
|
channel.QueueDeclare(qname, true, false, false, dic);
|
var properties = channel.CreateBasicProperties();
|
properties.DeliveryMode = 2;
|
properties.Persistent = true;
|
var body = Encoding.UTF8.GetBytes(message);
|
channel.BasicPublish("", qname, properties, body);
|
}
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
return ex.ToString();
|
}
|
|
return "ok";
|
}
|
|
/// <summary>
|
/// 添加延时消息
|
/// </summary>
|
/// <param name="param"></param>
|
/// <param name="message"></param>
|
/// <param name="sendtime"></param>
|
/// <returns></returns>
|
public string SendDelayMessage(MQClientParam param, string message, DateTime sendtime)
|
{
|
string mqname = queueName;
|
if (string.IsNullOrWhiteSpace(mqname))
|
{
|
return "传入的参数不正确!";
|
}
|
|
return SendDelayMessage(param, mqname, message, sendtime);
|
}
|
|
|
/// <summary>
|
/// 添加延时消息
|
/// </summary>
|
/// <param name="mode">0-独立 1-集群</param>
|
/// <param name="mqname"></param>
|
/// <param name="message"></param>
|
/// <param name="sendtime"></param>
|
/// <returns></returns>
|
public string SendDelayMessage(int mode, string mqname, string message, DateTime sendtime)
|
{
|
MQClientParam param;
|
string ret = GetParam(mode, out param);
|
if (ret != "ok") return ret;
|
return SendDelayMessage(param, mqname, message, sendtime);
|
}
|
|
/// <summary>
|
/// 添加延时消息
|
/// </summary>
|
/// <param name="mode"></param>
|
/// <param name="message"></param>
|
/// <param name="sendtime"></param>
|
/// <returns></returns>
|
public string SendDelayMessage(int mode, string message, DateTime sendtime)
|
{
|
string mqname = queueName;
|
if (string.IsNullOrWhiteSpace(mqname))
|
{
|
return "传入的参数不正确!";
|
}
|
|
MQClientParam param;
|
string ret = GetParam(mode, out param);
|
if (ret != "ok") return ret;
|
return SendDelayMessage(param, mqname, message, sendtime);
|
}
|
|
|
#endregion
|
|
#region 接收消息
|
|
/// <summary>
|
/// 消息到达客户端发起的事件
|
/// </summary>
|
/// <param name="result">BasicDeliverEventArgs消息对象</param>
|
public delegate void ActionEvent(EventMessageResultCluster result);
|
|
/// <summary>
|
/// 事件激活委托实例
|
/// </summary>
|
private ActionEvent _onMessage;
|
|
/// <summary>
|
/// 当侦听的队列中有消息到达时触发的执行事件
|
/// </summary>
|
public event ActionEvent OnMessage
|
{
|
add
|
{
|
if (_onMessage == null)
|
{
|
_onMessage += value;
|
}
|
}
|
remove
|
{
|
if (_onMessage != null)
|
{
|
_onMessage -= value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 连接成功
|
/// </summary>
|
private Action<MQClientParam> _onConnected;
|
|
/// <summary>
|
/// 链接成功回调
|
/// </summary>
|
public event Action<MQClientParam> OnConnected
|
{
|
add
|
{
|
if (_onConnected == null)
|
{
|
_onConnected += value;
|
}
|
}
|
remove
|
{
|
if (_onConnected != null)
|
{
|
_onConnected -= value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 链接成功回调
|
/// </summary>
|
/// <param name="param"></param>
|
public void Connected(MQClientParam param)
|
{
|
if (_onConnected != null)
|
{
|
_onConnected(param);
|
}
|
}
|
|
/// <summary>
|
/// 连接断开
|
/// </summary>
|
private Action<MQClientParam> _onDisConnected;
|
|
/// <summary>
|
/// 连接断开回调
|
/// </summary>
|
public event Action<MQClientParam> OnDisConnected
|
{
|
add
|
{
|
if (_onDisConnected == null)
|
{
|
_onDisConnected += value;
|
}
|
}
|
remove
|
{
|
if (_onDisConnected != null)
|
{
|
_onDisConnected -= value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 连接断开回调
|
/// </summary>
|
/// <param name="param"></param>
|
public void DisConnected(MQClientParam param)
|
{
|
if (_onDisConnected != null)
|
{
|
_onDisConnected(param);
|
}
|
}
|
|
|
/// <summary>
|
/// 侦听初始化
|
/// </summary>
|
/// <param name="param"></param>
|
/// <returns></returns>
|
public void ConnectInit(MQClientParam param)
|
{
|
try
|
{
|
string fqname = queueName;
|
ConnectionFactory factory = new ConnectionFactory();
|
factory.HostName = param.HostName;
|
factory.UserName = param.UserName;
|
factory.Password = param.Password;
|
factory.Port = param.Port;
|
factory.VirtualHost = param.VirtualHost;
|
factory.AutomaticRecoveryEnabled = true;
|
factory.NetworkRecoveryInterval = TimeSpan.FromSeconds(10);
|
connectionReceive = factory.CreateConnection();
|
|
connectionReceive.ConnectionShutdown += (o, e) =>
|
{
|
Task.Run(() =>
|
{
|
LogUtil.Info(JSONUtil.ObjectToJson(param) + " --> 链接关闭", logName);
|
});
|
|
// 调用链接关闭的回调
|
DisConnected(param);
|
|
// 关闭
|
Close();
|
|
if (reConnectTime > 0)
|
{
|
//等待并重新链接
|
Task.Delay(reConnectTime).Wait();
|
ConnectInit(param);
|
}
|
};
|
|
|
//获取通道
|
channelReceive = connectionReceive.CreateModel();
|
channelReceive.ExchangeDeclare(exchange: "exchange-direct", type: "direct");
|
channelReceive.QueueBind(fqname, "exchange-direct", fqname);
|
|
//创建事件驱动的消费者类型
|
var consumer = new EventingBasicConsumer(channelReceive);
|
consumer.Received += consumer_Received;
|
channelReceive.BasicQos(0, 1, false); //一次只获取一个消息进行消费
|
channelReceive.BasicConsume(fqname, false, consumer);
|
|
// 链接成功,调用一下通知调用者
|
if (connectionReceive.IsOpen)
|
{
|
this.Connected(param);
|
}
|
}
|
catch (Exception ee)
|
{
|
Task.Run(() =>
|
{
|
LogUtil.Info("ConnectInit(MQClientParam param)异常:" + ee.Message.ToSingular(), logName);
|
});
|
|
// 调用链接关闭的回调
|
DisConnected(param);
|
|
// 关闭
|
Close();
|
|
if (reConnectTime > 0)
|
{
|
//等待并重新链接
|
Task.Delay(reConnectTime).Wait();
|
ConnectInit(param);
|
}
|
}
|
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="mode">0-表示监听独立的,>0 表示监听集群中的某一个</param>
|
public string Connect(int mode)
|
{
|
// 根据mode获取参数
|
MQClientParam param;
|
string ret = "";
|
if (mode == 0)
|
{
|
//独立
|
ret = GetParam(0, out param);
|
if (ret != "ok")
|
{
|
return ret;
|
}
|
}
|
else
|
{
|
List<MQClientParam> pAll = new List<MQClientParam>();
|
ret = GetParam(out pAll);
|
if (ret != "ok")
|
{
|
return ret;
|
}
|
if (mode > pAll.Count())
|
{
|
return $"Items下没有第[{mode}]条记录";
|
}
|
param = pAll[mode - 1];
|
}
|
if (param == null)
|
{
|
return "MQ参数获取不正确!";
|
}
|
|
try
|
{
|
Task.Factory.StartNew(() =>
|
{
|
ConnectInit(param);
|
});
|
}
|
catch (Exception ex)
|
{
|
Task.Run(() =>
|
{
|
LogUtil.Error("Connect(int mode):" + ex.Message.ToString(), "MQClientFullChannel");
|
});
|
return ex.Message.ToString();
|
}
|
return "ok";
|
}
|
|
/// <summary>
|
/// 接受到消息
|
/// </summary>
|
private void consumer_Received(object sender, BasicDeliverEventArgs e)
|
{
|
try
|
{
|
EventMessageResultCluster emr = new EventMessageResultCluster();
|
string message = Encoding.UTF8.GetString(e.Body);
|
//emr.ReplyToAddress = e.BasicProperties==null?"":e.BasicProperties.ReplyToAddress==null?"":e.BasicProperties.ReplyToAddress.ToString();
|
emr.ConsumerTag = e?.ConsumerTag?.ToString();
|
emr.RoutingKey = e?.RoutingKey?.ToString();
|
emr.Topic = "";
|
emr.Content = message;
|
if (_onMessage != null)
|
{
|
//触发外部侦听事件
|
_onMessage(emr);
|
}
|
|
if (emr.IsOperationOk == false)
|
{
|
//WriteLine("MQ日志", "未能消费此消息，重新放入队列头:" + message);
|
//未能消费此消息，重新放入队列头
|
channelReceive.BasicReject(e.DeliveryTag, false);
|
}
|
else if (channelReceive.IsClosed == false)
|
{
|
//WriteLine("MQ日志", "确认消息:" + message);
|
channelReceive.BasicAck(e.DeliveryTag, false);
|
//MqTraceLog.SaveTraceLog(queueName.ToString(), message, 1);
|
}
|
}
|
catch (Exception ex)
|
{
|
LogUtil.Error("接收消息出错:" + ex.ToString(), "MQClientFullChannel");
|
}
|
}
|
|
#endregion
|
|
#region 关闭链接
|
|
/// <summary>
|
/// 关闭连接
|
/// </summary>
|
public void Close()
|
{
|
try
|
{
|
if (channelReceive != null)
|
{
|
channelReceive.Close();
|
channelReceive.Dispose();
|
}
|
}
|
catch { }
|
|
try
|
{
|
if (connectionReceive != null)
|
{
|
connectionReceive.Close();
|
connectionReceive.Dispose();
|
}
|
}
|
catch { }
|
|
}
|
|
#endregion
|
|
|
#region 获取appsetting.json中的MQ参数
|
/// <summary>
|
/// 获取MQ参数
|
/// </summary>
|
/// <param name="mode">0-独立 1-集群</param>
|
/// <param name="param"></param>
|
/// <returns></returns>
|
public string GetParam(int mode, out MQClientParam param)
|
{
|
param = null;
|
// 获取appsetting.json文件中的MQConfig信息
|
JArray mqItem = null;
|
if (mode == 0)
|
{
|
// 独立
|
mqItem = (JArray)JSONUtil.JsonToObject(JSONUtil.ObjectToJson((ConfigUtil.GetChildren($"MQConfig"))));
|
if (mqItem == null || mqItem.Count() < 4)
|
{
|
return "MQ集群参数配置不正确,参数过少!";
|
}
|
}
|
else
|
{
|
//指定
|
var items = ConfigUtil.GetChildren("MQConfig:Items");
|
if (items.Count() < 1)
|
{
|
return "没有配置MQ集群参数";
|
}
|
|
// 随即获取要使用哪个MQConfig
|
//int rm = new Random().Next(0, items.Count());
|
int rm = mode;
|
// 获取参数
|
mqItem = (JArray)JSONUtil.JsonToObject(JSONUtil.ObjectToJson((ConfigUtil.GetChildren($"MQConfig:Items:{rm}"))));
|
if (mqItem == null || mqItem.Count() < 4)
|
{
|
return "MQ集群参数配置不正确,参数过少!";
|
}
|
|
}
|
param = new MQClientParam();
|
try
|
{
|
foreach (var tmp in mqItem)
|
{
|
switch (tmp["Key"].ToString().ToLower())
|
{
|
case "hostname":
|
param.HostName = tmp["Value"].ToString();
|
break;
|
case "port":
|
param.Port = Convert.ToInt32(tmp["Value"]);
|
break;
|
case "username":
|
param.UserName = tmp["Value"].ToString();
|
break;
|
case "password":
|
param.Password = tmp["Value"].ToString();
|
break;
|
case "retrycount":
|
param.RetryCount = Convert.ToInt32(tmp["Value"]);
|
break;
|
case "virtualhost":
|
param.VirtualHost = tmp["Value"].ToString();
|
break;
|
}
|
}
|
}
|
catch (Exception ee)
|
{
|
return "MQ集群参数设置不正确!" + ee.Message.ToString();
|
}
|
|
if (param == null)
|
{
|
return "MQ参数获取失败!";
|
}
|
return "ok";
|
}
|
|
|
/// <summary>
|
/// 获取所有集群参数
|
/// </summary>
|
/// <param name="paramAll"></param>
|
/// <returns></returns>
|
public string GetParam(out List<MQClientParam> paramAll)
|
{
|
paramAll = null;
|
//集群
|
var items = ConfigUtil.GetChildren("MQConfig:Items");
|
if (items.Count() < 1)
|
{
|
return "没有配置MQ集群参数";
|
}
|
for (int i = 0; i < items.Count(); i++)
|
{
|
JArray mqItem = (JArray)JSONUtil.JsonToObject(JSONUtil.ObjectToJson((ConfigUtil.GetChildren($"MQConfig:Items:{i}"))));
|
if (mqItem == null || mqItem.Count() < 4)
|
{
|
continue;
|
}
|
|
// 循环获取
|
MQClientParam param = new MQClientParam();
|
try
|
{
|
foreach (var tmp in mqItem)
|
{
|
switch (tmp["Key"].ToString().ToLower())
|
{
|
case "hostname":
|
param.HostName = tmp["Value"].ToString();
|
break;
|
case "port":
|
param.Port = Convert.ToInt32(tmp["Value"]);
|
break;
|
case "username":
|
param.UserName = tmp["Value"].ToString();
|
break;
|
case "password":
|
param.Password = tmp["Value"].ToString();
|
break;
|
case "retrycount":
|
param.RetryCount = Convert.ToInt32(tmp["Value"]);
|
break;
|
case "virtualhost":
|
param.VirtualHost = tmp["Value"].ToString();
|
break;
|
}
|
}
|
}
|
catch (Exception ee)
|
{
|
LogUtil.Error("MQ集群参数设置不正确:" + ee.Message.ToString(), "MQClientFullChannel");
|
continue;
|
}
|
paramAll = paramAll == null ? new List<MQClientParam>() : paramAll;
|
paramAll.Add(param);
|
}
|
|
return "ok";
|
}
|
|
|
|
#endregion
|
|
|
/// <summary>
|
/// 具体发送的参数
|
/// </summary>
|
public class MQClientParam
|
{
|
/// <summary>
|
/// MQ服务器地址
|
/// </summary>
|
public string HostName { get; set; }
|
|
/// <summary>
|
/// MQ服务器端口
|
/// </summary>
|
public int Port { get; set; }
|
|
/// <summary>
|
/// MQ登录名
|
/// </summary>
|
public string UserName { get; set; }
|
|
/// <summary>
|
/// MQ密码
|
/// </summary>
|
public string Password { get; set; }
|
|
/// <summary>
|
///
|
/// </summary>
|
public string VirtualHost { get; set; }
|
|
/// <summary>
|
///
|
/// </summary>
|
public int RetryCount { get; set; }
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
public class RabbitMQSetCluster
|
{
|
private string hostname = "106.14.15.190";
|
/// <summary>
|
/// 地址
|
/// </summary>
|
public string HostName
|
{
|
get { return this.hostname; }
|
}
|
|
|
private List<string> listhostname = new List<string>(new string[] { "106.14.15.190", "106.14.223.74", "101.132.39.50" });
|
|
/// <summary>
|
///
|
/// </summary>
|
public List<string> HostNameList
|
{
|
get { return this.listhostname; }
|
}
|
|
|
|
private int port = 8102;
|
/// <summary>
|
/// 端口
|
/// </summary>
|
public int Port
|
{
|
get { return this.port; }
|
}
|
|
private string username = "duomaicrm";
|
/// <summary>
|
/// 用户名
|
/// </summary>
|
public string UserName
|
{
|
get { return this.username; }
|
}
|
|
private string password = "taocrm123";
|
/// <summary>
|
/// 密码
|
/// </summary>
|
public string Password
|
{
|
get { return this.password; }
|
}
|
}
|
|
|
/// <summary>
|
///
|
/// </summary>
|
public class EventMessageResultCluster
|
{
|
/// <summary>
|
///
|
/// </summary>
|
public string Topic { get; set; }
|
|
/// <summary>
|
///
|
/// </summary>
|
public string Content { get; set; }
|
|
/// <summary>
|
/// 消息处理是否成功
|
/// </summary>
|
public bool IsOperationOk { get; set; }
|
|
/// <summary>
|
///
|
/// </summary>
|
public void Confirm()
|
{
|
this.IsOperationOk = true;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
public void Fail()
|
{
|
this.IsOperationOk = false;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
public string ConsumerTag { get; set; }
|
|
/// <summary>
|
///
|
///
|
/// </summary>
|
public string RoutingKey { get; set; }
|
|
}
|
|
|
}
|
}
|
