基于MqttNet的二次封装MQTT在.Net中的使用实例，附调用

最近需要处理一些协议连接和调用。

一开始想着是基于RabbitMq（我们本身就在用）来做Mqtt服务的转发。

后面想着既然要用客户端，那就顺路封装一个服务端吧，于是有了这篇文章。

 

先说环境

 <TargetFramework>net6.0</TargetFramework>

  <ItemGroup>
    <PackageReference Include="MQTTnet" Version="3.1.2" />
  </ItemGroup>

 

服务端调用示例

//var server = new MqttServer(s =>
//{
//    s.ConnectionValidator = new MqttServerConnValidator { Port = 1884,};
//    //消息回调
//    s.MessageReceived = s =>
//    {
//        Console.WriteLine(s.Msg);
//    };
//    //用户连接回调
//    s.ClientConnected = s =>
//    {
//        Console.WriteLine(s.Msg);
//    };
//    //用户订阅回调
//    s.SubscribedTopic = s =>
//    {
//        Console.WriteLine(s.Msg);
//    };
//}, true);//直接启动

服务端代码

using MQTTnet;
using MQTTnet.Protocol;
using MQTTnet.Server;
using System.Text;

namespace MQTT
{
    public class MqttServer
    {
        #region Field Area

        /// <summary>
        /// Mqtt服务端
        /// </summary>
        private IMqttServer _mqttServer;
        /// <summary>
        /// MqttOptions
        /// </summary>
        private MqttServerOptions _options;
        /// <summary>
        /// Mqtt配置信息
        /// </summary>
        private MqttServerConfig _mqttServerConfig;

        #endregion

        #region CTOR

        /// <summary>
        /// 调用示例
        /// 
        /// var server = new MqttServer(s =>
        /// {
        ///     s.ConnectionValidator = new MqttServerConnValidator { Port = 1884,};
        ///     //消息回调
        ///     s.MessageReceived = s =>
        ///     {
        ///         Console.WriteLine(s.Msg);
        ///     };
        ///     //用户连接回调
        ///     s.ClientConnected = s =>
        ///     {
        ///         Console.WriteLine(s.Msg);
        ///     };
        ///     //用户订阅回调
        ///     s.SubscribedTopic = s =>
        ///     {
        ///         Console.WriteLine(s.Msg);
        ///     };
        /// }, true);//直接启动
        /// </summary>
        public MqttServer()
        {
            Init();
        }
        /// <summary>
        /// MqttServer
        /// 
        /// 调用示例
        /// 
        /// var server = new MqttServer(s =>
        /// {
        ///     s.ConnectionValidator = new MqttServerConnValidator { Port = 1884,};
        ///     //消息回调
        ///     s.MessageReceived = s =>
        ///     {
        ///         Console.WriteLine(s.Msg);
        ///     };
        ///     //用户连接回调
        ///     s.ClientConnected = s =>
        ///     {
        ///         Console.WriteLine(s.Msg);
        ///     };
        ///     //用户订阅回调
        ///     s.SubscribedTopic = s =>
        ///     {
        ///         Console.WriteLine(s.Msg);
        ///     };
        /// }, true);//直接启动
        /// </summary>
        /// <param name="mqConfig">配置回调和参数</param>
        /// <param name="autoStartMqtt">是否直接启动mqtt服务</param>
        public MqttServer(Action<MqttServerConfig> mqConfig, bool autoStartMqtt = false)
        {
            _mqttServerConfig = new MqttServerConfig();
            mqConfig(_mqttServerConfig);
            Init();
            if (autoStartMqtt)
            {
                Start().Wait();
            }
        }

        #endregion

        /// <summary>
        /// 获取实例
        /// </summary>
        /// <param name="mqConfig">MQTT配置</param>
        /// <param name="autoStartMqtt">是否直接启动</param>
        /// <returns></returns>
        public static MqttServer Instance(Action<MqttServerConfig> mqConfig, bool autoStartMqtt = false)
        {
            return new MqttServer(mqConfig, autoStartMqtt);
        }

        /// <summary>
        /// 初始化MQTT
        /// </summary>
        private void Init()
        {
            try
            {
                #region Validator

                if (_mqttServerConfig.ConnectionValidator != null)
                {
                    //验证客户端信息比如客户Id、用户名、密码
                    _options = new MqttServerOptions
                    {
                        //连接验证
                        ConnectionValidator = new MqttServerConnectionValidatorDelegate(p =>
                        {
                            if (_mqttServerConfig.ConnectionValidator.ClientIds != null && 
                                _mqttServerConfig.ConnectionValidator.ClientIds.Count > 0)
                            {
                                if (_mqttServerConfig.ConnectionValidator.ClientIds.First(s => s.Equals(p.ClientId)) is null)
                                {
                                    p.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
                                }
                            }

                            if (_mqttServerConfig.ConnectionValidator.Usernames != null &&
                                _mqttServerConfig.ConnectionValidator.Passwords != null &&
                                _mqttServerConfig.ConnectionValidator.Usernames.Count > 0 &&
                                _mqttServerConfig.ConnectionValidator.Passwords.Count > 0)
                            {
                                if (_mqttServerConfig.ConnectionValidator.Usernames.First(s => s.Equals(p.Username)) is null ||
                                    _mqttServerConfig.ConnectionValidator.Usernames.First(s => s.Equals(p.Username)) is null)
                                {
                                    p.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
                                }
                            }
                            
                        }),
                    };
                    if (_mqttServerConfig.ConnectionValidator.Port > 0)
                    {
                        //验证客户端端口和服务器端口是否一致（不一致则不能连接到服务器成功）
                        _options.DefaultEndpointOptions.Port = _mqttServerConfig.ConnectionValidator.Port;
                    }
                }
                else
                {
                    _options = new MqttServerOptions();
                }

                #endregion

                #region Event Binding

                //创建Mqtt服务器
                _mqttServer = new MqttFactory().CreateMqttServer();

                //开启订阅事件
                _mqttServer.ClientSubscribedTopicHandler = new MqttServerClientSubscribedTopicHandlerDelegate(MqttNetServer_SubscribedTopic);

                //取消订阅事件
                _mqttServer.ClientUnsubscribedTopicHandler = new MqttServerClientUnsubscribedTopicHandlerDelegate(MqttNetServer_UnSubscribedTopic);

                //客户端消息事件
                _mqttServer.UseApplicationMessageReceivedHandler(MqttServe_ApplicationMessageReceived);

                //客户端连接事件
                _mqttServer.UseClientConnectedHandler(MqttNetServer_ClientConnected);

                //客户端断开事件
                _mqttServer.UseClientDisconnectedHandler(MqttNetServer_ClientDisConnected);

                #endregion

            }
            catch (Exception e)
            {
                if (_mqttServerConfig.ExceptionCallBack is null)
                {
                    throw e;
                }
                _mqttServerConfig.ExceptionCallBack(e);
            }

        }

        /// <summary>
        /// //启动服务器
        /// </summary>
        /// <returns></returns>
        public async Task Start()
            => await _mqttServer.StartAsync(_options);

        /// <summary>
        /// 停止服务
        /// </summary>
        /// <returns></returns>
        public async Task Stop()
            => await _mqttServer.StopAsync();

        #region 内部事件转换处理

        /// <summary>
        /// //客户订阅
        /// </summary>
        /// <param name="e"></param>
        private void MqttNetServer_SubscribedTopic(MqttServerClientSubscribedTopicEventArgs e)
        {
            if (_mqttServerConfig.SubscribedTopic != null)
            {
                _mqttServerConfig.SubscribedTopic(new MqttServerRecive
                {
                    ClientId = e.ClientId,//客户端Id
                    Topic = e.TopicFilter.Topic,
                    Msg = $"客户端[{ e.ClientId}]已订阅主题：{e.TopicFilter.Topic}"
                });
            }
        }

        /// <summary>
        /// //客户取消订阅
        /// </summary>
        /// <param name="e"></param>
        private void MqttNetServer_UnSubscribedTopic(MqttServerClientUnsubscribedTopicEventArgs e)
        {
            if (_mqttServerConfig.UnSubscribedTopic != null)
            {
                _mqttServerConfig.UnSubscribedTopic(new MqttServerRecive
                {
                    ClientId = e.ClientId,//客户端Id
                    Topic = e.TopicFilter,
                    Msg = $"客户端[{ e.ClientId}]已取消订阅主题：{e.TopicFilter}"
                });
            }
        }

        /// <summary>
        /// //接收消息
        /// </summary>
        /// <param name="e"></param>
        private void MqttServe_ApplicationMessageReceived(MqttApplicationMessageReceivedEventArgs e)
        {
            var Payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
            var Retain = e.ApplicationMessage.Retain;
            if (_mqttServerConfig.MessageReceived != null)
            {
                _mqttServerConfig.MessageReceived(new MqttServerRecive
                {
                    ClientId = e.ClientId,//客户端Id
                    Topic = e.ApplicationMessage.Topic,
                    Payload = Payload,
                    Qos = e.ApplicationMessage.QualityOfServiceLevel,
                    Retain = e.ApplicationMessage.Retain,
                    Msg = $"客户端[{e.ClientId}]>> 主题：[{e.ApplicationMessage.Topic}] " +
                            $"负载：[{Payload}] Qos：[{e.ApplicationMessage.QualityOfServiceLevel}] " +
                            $"保留：[{e.ApplicationMessage.Retain}]"
                });
            }
        }

        /// <summary>
        /// //客户连接
        /// </summary>
        /// <param name="e"></param>
        private void MqttNetServer_ClientConnected(MqttServerClientConnectedEventArgs e)
        {
            if (_mqttServerConfig.ClientConnected != null)
            {
                _mqttServerConfig.ClientConnected(new MqttServerRecive
                {
                    ClientId = e.ClientId,//客户端Id
                    Msg = $"客户端[{ e.ClientId}]已连接"
                });
            }
        }

        /// <summary>
        /// //客户连接断开
        /// </summary>
        /// <param name="e"></param>
        private void MqttNetServer_ClientDisConnected(MqttServerClientDisconnectedEventArgs e)
        {
            if (_mqttServerConfig.ClientDisConnected != null)
            {
                _mqttServerConfig.ClientDisConnected(new MqttServerRecive
                {
                    ClientId = e.ClientId,//客户端Id
                    Msg = $"客户端[{ e.ClientId}]已断开连接"
                });
            }
        }

        #endregion
    }

    public class MqttServerConfig
    {
        /// <summary>
        /// Mqtt验证
        /// </summary>
        public MqttServerConnValidator ConnectionValidator = null;
        /// <summary>
        /// 客户订阅信息提醒
        /// </summary>
        public Action<MqttServerRecive> SubscribedTopic = null;
        /// <summary>
        /// 客户取消订阅提醒
        /// </summary>
        public Action<MqttServerRecive> UnSubscribedTopic = null;
        /// <summary>
        /// 接收消息
        /// </summary>
        public Action<MqttServerRecive> MessageReceived = null;
        /// <summary>
        /// 客户连接提醒
        /// </summary>
        public Action<MqttServerRecive> ClientConnected = null;
        /// <summary>
        /// 客户连接断开提醒
        /// </summary>
        public Action<MqttServerRecive> ClientDisConnected = null;
        /// <summary>
        /// 异常信息回调（建议设置）
        /// </summary>
        public Action<Exception> ExceptionCallBack = null;
    }

    public class MqttServerConnValidator
    {
        /// <summary>
        /// Connecte Client Id
        /// </summary>
        public IList<string> ClientIds { get; set; }

        /// <summary>
        /// Verify Username
        /// </summary>
        public IList<string> Usernames { get; set; }

        /// <summary>
        /// Verify Password
        /// </summary>
        public IList<string> Passwords { get; set; }

        /// <summary>
        /// Verify Port
        /// </summary>
        public int Port { get; set; }
    }

    public class MqttServerRecive
    {
        /// <summary>
        /// 客户端ID
        /// </summary>
        public string ClientId { get; set; }
        /// <summary>
        /// 主题
        /// </summary>
        public string Topic { get; set; }
        /// <summary>
        /// 负载/消息
        /// </summary>
        public string Payload { get; set; }
        /// <summary>
        /// Qos
        /// </summary>
        public MqttQualityOfServiceLevel Qos { get; set; }
        /// <summary>
        /// 保留
        /// </summary>
        public bool Retain { get; set; }
        /// <summary>
        /// 消息内容
        /// </summary>
        public string Msg { get; set; }
    }
}

客户端调用示例

//var client = new MqttClient(s =>
//{
//    s.Port = 1883;
//    s.ServerIp = "127.0.0.1";
//    s.UserName = "mqtt-test";
//    s.Password = "mqtt-test";
//    s.ReciveMsgCallback = s =>
//    {
//        Console.WriteLine(s.Payload_UTF8);
//    };
//}, true);
//client.Subscribe("/iot/");

客户端代码

using MQTTnet;
using MQTTnet.Client;
using MQTTnet.Client.Disconnecting;
using MQTTnet.Client.Options;
using MQTTnet.Protocol;
using System.Text;

namespace MQTT
{
    public class MqttClient
    {
        #region Field Area

        /// <summary>
        /// Mqtt factory
        /// </summary>
        private MqttFactory _factory;
        /// <summary>
        /// Mqtt client
        /// </summary>
        private IMqttClient _mqttClient;
        /// <summary>
        /// Mqtt 配置信息
        /// </summary>
        private MqttClientConfig _mqttClientConfig;
        /// <summary>
        /// Mqtt options
        /// </summary>
        private IMqttClientOptions _options;

        #endregion

        #region CTOR

        /// <summary>
        /// 默认启动IP为127.0.0.1 端口为1883
        /// </summary>
        public MqttClient()
        {
            _mqttClientConfig = new MqttClientConfig
            {
                ServerIp = "127.0.0.1",
                Port = 1883
            };
            Init();
        }
        /// <summary>
        /// 调用示例
        /// 
        /// //var client = new MqttClient(s =>
        ///    {
        ///        s.Port = 1883;
        ///        s.ServerIp = "127.0.0.1";
        ///        s.UserName = "mqtt-test";
        ///        s.Password = "mqtt-test";
        ///        s.ReciveMsgCallback = s =>
        ///        {
        ///            Console.WriteLine(s.Payload_UTF8);
        ///        };
        ///    }, true);
        ///    client.Subscribe("/TopicName/");
        /// </summary>
        /// <param name="config">客户端配置信息</param>
        /// <param name="autoStart">直接启动</param>
        public MqttClient(Action<MqttClientConfig> config, bool autoStart = false)
        {
            _mqttClientConfig = new MqttClientConfig();
            config(_mqttClientConfig);
            Init();
            if (autoStart)
            {
                Start();
            }
        }

        #endregion

        /// <summary>
        /// 获取MqttClient实例
        /// 
        /// 调用示例
        ///    //var client = MqttClient.Instance(s =>
        ///    {
        ///        s.Port = 1883;
        ///        s.ServerIp = "127.0.0.1";
        ///        s.UserName = "mqtt-test";
        ///        s.Password = "mqtt-test";
        ///        s.ReciveMsgCallback = s =>
        ///        {
        ///            Console.WriteLine(s.Payload_UTF8);
        ///        };
        ///    }, true);
        ///    client.Subscribe("/TopicName/");
        /// </summary>
        /// <param name="config">客户端配置信息</param>
        /// <param name="autoStart">直接启动</param>
        /// <returns></returns>
        public static MqttClient Instance(Action<MqttClientConfig> config, bool autoStart = false)
            => new MqttClient(config, autoStart);

        /// <summary>
        /// 初始化注册
        /// </summary>
        private void Init()
        {
            try
            {
                _factory = new MqttFactory();

                _mqttClient = _factory.CreateMqttClient();

                _options = new MqttClientOptionsBuilder()
                    .WithTcpServer(_mqttClientConfig.ServerIp, _mqttClientConfig.Port)
                    .WithCredentials(_mqttClientConfig.UserName, _mqttClientConfig.Password)
                    .WithClientId(_mqttClientConfig.ClientId)
                    .Build();

                //消息回调
                _mqttClient.UseApplicationMessageReceivedHandler(ReciveMsg);
            }
            catch (Exception exp)
            {
                if (_mqttClientConfig.Exception is null)
                {
                    throw exp;
                }
                _mqttClientConfig.Exception(exp);
            }
        }

        #region 内部事件转换处理

        /// <summary>
        /// 消息接收回调
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        private void ReciveMsg(MqttApplicationMessageReceivedEventArgs e)
        {
            if (_mqttClientConfig.ReciveMsgCallback != null)
            {
                _mqttClientConfig.ReciveMsgCallback(new MqttClientReciveMsg
                {
                    Topic = e.ApplicationMessage.Topic,
                    Payload_UTF8 = Encoding.UTF8.GetString(e.ApplicationMessage.Payload),
                    Payload = e.ApplicationMessage.Payload,
                    Qos = e.ApplicationMessage.QualityOfServiceLevel,
                    Retain = e.ApplicationMessage.Retain,
                });
            }
        }

        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="topicName"></param>
        public async void Subscribe(string topicName)
        {
            topicName = topicName.Trim();
            if (string.IsNullOrEmpty(topicName))
            {
                throw new Exception("订阅主题不能为空！");
            }

            if (!_mqttClient.IsConnected)
            {
                throw new Exception("MQTT客户端尚未连接！请先启动连接");
            }
            await _mqttClient.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic(topicName).Build());
        }

        /// <summary>
        /// 取消订阅
        /// </summary>
        /// <param name="topicName"></param>
        public async void Unsubscribe(string topicName)
        {
            topicName = topicName.Trim();
            if (string.IsNullOrEmpty(topicName))
            {
                throw new Exception("订阅主题不能为空！");
            }

            if (!_mqttClient.IsConnected)
            {
                throw new Exception("MQTT客户端尚未连接！请先启动连接");
            }
            await _mqttClient.UnsubscribeAsync(topicName);
        }

        /// <summary>
        /// 重连机制
        /// </summary>
        private void ReConnected()
        {
            if (_mqttClient.IsConnected)
            {
                return;
            }
            for (int i = 0; i < 10; i++)
            {
                //重连机制
                _mqttClient.UseDisconnectedHandler(async e =>
                {
                    try
                    {
                        await Task.Delay(TimeSpan.FromSeconds(_mqttClientConfig.ReconneTime));
                        await _mqttClient.ConnectAsync(_options);
                        return;
                    }
                    catch (Exception exp)
                    {
                        if (_mqttClientConfig.Exception is null)
                        {
                            throw exp;
                        }
                        _mqttClientConfig.Exception(exp);
                    }
                });
            }
        }

        #endregion

        #region 消息发送

        /// <summary>
        /// 发送消息,含有重连机制，如掉线会自动重连
        /// </summary>
        /// <param name="message"></param>
        private async Task PublishAsync(string topicName, MqttApplicationMessageBuilder MessageBuilder, PublicQos qos = 0)
        {
            string topic = topicName.Trim();
            if (string.IsNullOrEmpty(topic))
            {
                throw new Exception("主题不能为空！");
            }
            ReConnected();

            MessageBuilder.WithTopic(topic).WithRetainFlag();
            if (qos == PublicQos.Qos_0)
            {
                MessageBuilder.WithAtLeastOnceQoS();
            }
            else if (qos == PublicQos.Qos_1)
            {
                MessageBuilder.WithAtMostOnceQoS();
            }
            else
            {
                MessageBuilder.WithExactlyOnceQoS();
            }
            var Message = MessageBuilder.Build();
            try
            {
                await _mqttClient.PublishAsync(Message);
            }
            catch (Exception e)
            {
                if (_mqttClientConfig.Exception is null)
                {
                    throw e;
                }
                _mqttClientConfig.Exception(e);
            }

        }

        /// <summary>
        /// 发送消息,含有重连机制，如掉线会自动重连
        /// </summary>
        /// <param name="message">文字消息</param>
        public async Task Publish(string topicName, string message, PublicQos qos = 0)
        {
            await PublishAsync(topicName, new MqttApplicationMessageBuilder()
                .WithPayload(message), qos);
        }
        /// <summary>
        /// 发送消息,含有重连机制，如掉线会自动重连
        /// </summary>
        /// <param name="message">消息流</param>
        public async void Publish(string topicName, Stream message, PublicQos qos = 0)
            => await PublishAsync(topicName, new MqttApplicationMessageBuilder()
                .WithPayload(message), qos);

        /// <summary>
        /// 发送消息,含有重连机制，如掉线会自动重连
        /// </summary>
        /// <param name="message">Byte消息</param>
        public async void Publish(string topicName, IEnumerable<byte> message, PublicQos qos = 0)
            => await PublishAsync(topicName, new MqttApplicationMessageBuilder()
                .WithPayload(message), qos);

        /// <summary>
        /// 发送消息,含有重连机制，如掉线会自动重连
        /// </summary>
        /// <param name="message">Byte消息</param>
        public async void Publish(string topicName, byte[] message, PublicQos qos = 0)
            => await PublishAsync(topicName, new MqttApplicationMessageBuilder()
                .WithPayload(message), qos);

        #endregion

        /// <summary>
        /// 启动服务
        /// </summary>
        /// <returns></returns>
        public async Task Start()
            => await _mqttClient.ConnectAsync(_options);

        /// <summary>
        /// 停止服务
        /// </summary>
        /// <returns></returns>
        public async Task Stop()
            => await _mqttClient.DisconnectAsync(new MqttClientDisconnectOptions { ReasonCode = MqttClientDisconnectReason.NormalDisconnection}, CancellationToken.None);

    }
    public class MqttClientConfig
    {
        private string _serverIp;
        /// <summary>
        /// 服务器IP
        /// </summary>
        public string ServerIp
        {
            get => _serverIp;
            set
            {
                if (string.IsNullOrEmpty(value.Trim()))
                {
                    throw new ArgumentException("ServerIp can't be null or empty!");
                }
                _serverIp = value;
            }
        }
        private int _port;
        /// <summary>
        /// 服务器端口
        /// </summary>
        public int Port
        {
            get => _port;
            set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("Port can't below the zero!");
                }
                _port = value;
            }
        }

        /// <summary>
        /// 用户名
        /// </summary>
        public string UserName { get; set; }
        /// <summary>
        /// 密码
        /// </summary>
        public string Password { get; set; }

        private string _clientId;
        /// <summary>
        /// 唯一用户ID，默认使用Guid
        /// </summary>
        public string ClientId
        {
            get
            {
                _clientId = _clientId ?? Guid.NewGuid().ToString();
                return _clientId;
            }
            set => _clientId = value;
        }
        /// <summary>
        /// 客户端掉线重连时间，单位/s，默认5s
        /// </summary>
        public double ReconneTime { get; set; } = 5;
        /// <summary>
        /// 异常回调，默认为空，为空抛异常
        /// </summary>
        public Action<Exception> Exception = null;

        /// <summary>
        /// 接收消息回调，默认不接收
        /// </summary>
        public Action<MqttClientReciveMsg> ReciveMsgCallback = null;
    }
    public class MqttClientReciveMsg
    {
        /// <summary>
        /// 主题
        /// </summary>
        public string Topic { get; set; }
        /// <summary>
        /// UTF-8格式下的 负载/消息
        /// </summary>
        public string Payload_UTF8 { get; set; }
        /// <summary>
        /// 原始 负载/消息
        /// </summary>
        public byte[] Payload { get; set; }
        /// <summary>
        /// Qos
        /// </summary>
        public MqttQualityOfServiceLevel Qos { get; set; }
        /// <summary>
        /// 保留
        /// </summary>
        public bool Retain { get; set; }
    }
    public enum PublicQos
    {
        /// <summary>
        /// //At most once，至多一次
        /// </summary>
        Qos_0,
        /// <summary>
        /// //At least once，至少一次
        /// </summary>
        Qos_1,
        /// <summary>
        /// //QoS2，Exactly once
        /// </summary>
        Qos_2,
    }
}

 

所有的支持类都在里面，随用随跑。