Add more handling options to interceptor contexts.

Source/MQTTnet.AspnetCore/MqttConnectionContext.cs

@@ -173,7 +173,7 @@ namespace MQTTnet.AspNetCore
             using (await _writerLock.WaitAsync(cancellationToken).ConfigureAwait(false))
             {
                 var buffer = formatter.Encode(packet);
-                var msg = buffer.AsMemory();
+                var msg = buffer.ToArray().AsMemory();
                 var output = _output;
                 var result = await output.WriteAsync(msg, cancellationToken).ConfigureAwait(false);
                 if (result.IsCompleted)

Source/MQTTnet.AspnetCore/MqttHostedServer.cs

@@ -4,30 +4,137 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Hosting;
 using MQTTnet.Adapter;
+using MQTTnet.Client.Publishing;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Server;
+using MQTTnet.Server.Status;
 
 namespace MQTTnet.AspNetCore
 {
-    public sealed class MqttHostedServer : MqttServer, IHostedService
+    public sealed class MqttHostedServer : IMqttServer, IHostedService
     {
+        readonly MqttServer _mqttServer;
         readonly IMqttServerOptions _options;
 
-        public MqttHostedServer(IMqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) 
-            : base(adapters, logger)
+        public MqttHostedServer(IMqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
         {
             _options = options ?? throw new ArgumentNullException(nameof(options));
+
+            _mqttServer = new MqttServer(adapters, logger);
         }
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
-            _ = StartAsync(_options);
+            _ = _mqttServer.StartAsync(_options);
             return Task.CompletedTask;
         }
 
         public Task StopAsync(CancellationToken cancellationToken)
         {
-            return StopAsync();
+            return _mqttServer.StopAsync();
+        }
+
+        public IMqttApplicationMessageReceivedHandler ApplicationMessageReceivedHandler
+        {
+            get => _mqttServer.ApplicationMessageReceivedHandler;
+            set => _mqttServer.ApplicationMessageReceivedHandler = value;
+        }
+
+        public event Func<MqttApplicationMessageReceivedEventArgs, Task> ApplicationMessageReceivedAsync
+        {
+            add => _mqttServer.ApplicationMessageReceivedAsync += value;
+            remove => _mqttServer.ApplicationMessageReceivedAsync -= value;
+        }
+        
+        public Task<MqttClientPublishResult> PublishAsync(MqttApplicationMessage applicationMessage, CancellationToken cancellationToken)
+        {
+            return _mqttServer.PublishAsync(applicationMessage, cancellationToken);
+        }
+
+        public void Dispose()
+        {
+            _mqttServer.Dispose();
+        }
+
+        public bool IsStarted => _mqttServer.IsStarted;
+
+        public IMqttServerStartedHandler StartedHandler
+        {
+            get => _mqttServer.StartedHandler;
+            set => _mqttServer.StartedHandler = value;
+        }
+
+        public IMqttServerStoppedHandler StoppedHandler
+        {
+            get => _mqttServer.StoppedHandler;
+            set => _mqttServer.StoppedHandler = value;
+        }
+
+        public IMqttServerClientConnectedHandler ClientConnectedHandler
+        {
+            get => _mqttServer.ClientConnectedHandler;
+            set => _mqttServer.ClientConnectedHandler = value;
+        }
+
+        public IMqttServerClientDisconnectedHandler ClientDisconnectedHandler
+        {
+            get => _mqttServer.ClientDisconnectedHandler;
+            set => _mqttServer.ClientDisconnectedHandler = value;
+        }
+
+        public IMqttServerClientSubscribedTopicHandler ClientSubscribedTopicHandler
+        {
+            get => _mqttServer.ClientSubscribedTopicHandler;
+            set => _mqttServer.ClientSubscribedTopicHandler = value;
+        }
+
+        public IMqttServerClientUnsubscribedTopicHandler ClientUnsubscribedTopicHandler
+        {
+            get => _mqttServer.ClientUnsubscribedTopicHandler;
+            set => _mqttServer.ClientUnsubscribedTopicHandler = value;
+        }
+
+        public IMqttServerOptions Options => _mqttServer.Options;
+
+        public Task<IList<IMqttClientStatus>> GetClientStatusAsync()
+        {
+            return _mqttServer.GetClientStatusAsync();
+        }
+
+        public Task<IList<IMqttSessionStatus>> GetSessionStatusAsync()
+        {
+            return _mqttServer.GetSessionStatusAsync();
+        }
+
+        public Task<IList<MqttApplicationMessage>> GetRetainedApplicationMessagesAsync()
+        {
+            return _mqttServer.GetRetainedApplicationMessagesAsync();
+        }
+
+        public Task ClearRetainedApplicationMessagesAsync()
+        {
+            return _mqttServer.ClearRetainedApplicationMessagesAsync();
+        }
+
+        public Task SubscribeAsync(string clientId, ICollection<MqttTopicFilter> topicFilters)
+        {
+            return _mqttServer.SubscribeAsync(clientId, topicFilters);
+        }
+
+        public Task UnsubscribeAsync(string clientId, ICollection<string> topicFilters)
+        {
+            return _mqttServer.UnsubscribeAsync(clientId, topicFilters);
+        }
+
+        public Task StartAsync(IMqttServerOptions options)
+        {
+            return _mqttServer.StartAsync(options);
+        }
+
+        public Task StopAsync()
+        {
+            return _mqttServer.StopAsync();
         }
     }
-}
+}