Calling AsyncDispose instead of Dispose so we don't call ActionBlock.Completion.Wait()

Author: darkl

src/netstandard/Default/WampSharp.Fleck/Fleck/FleckWampConnection.cs

@@ -45,9 +45,9 @@ private void OnConnectionError(Exception exception)
             RaiseConnectionError(exception);
         }
 
-        private void OnConnectionClose()
+        private async void OnConnectionClose()
         {
-            RaiseConnectionClosed();
+            await RaiseConnectionClosed().ConfigureAwait(false);
         }
 
         protected override void Dispose()

src/netstandard/Extensions/WampSharp.AspNetCore.RawSocket/RawSocketConnection.cs

@@ -90,7 +90,7 @@ public async Task RunAsync()
                 mIsConnected = false;
             }
 
-            RaiseConnectionClosed();
+            await RaiseConnectionClosed().ConfigureAwait(false);
         }
 
         private void ProcessBuffer(in ReadOnlySequence<byte> buffer)

src/netstandard/Extensions/WampSharp.RawSocket/RawSocket/TcpClientConnection.cs

@@ -111,7 +111,7 @@ await Stream
                     }
                 }
 
-                RaiseConnectionClosed();
+                await RaiseConnectionClosed().ConfigureAwait(false);
             }
             catch (Exception ex)
             {

src/netstandard/Extensions/WampSharp.Vtortola/VtortolaWampConnection.cs

@@ -49,7 +49,7 @@ await mWebsocket.ReadMessageAsync(CancellationToken.None)
                     }
                 }
 
-                RaiseConnectionClosed();
+                await RaiseConnectionClosed().ConfigureAwait(false);
             }
             catch (Exception ex)
             {

src/netstandard/Extensions/WampSharp.WebSockets/WebSockets/WebSocketWrapperConnection.cs

@@ -76,7 +76,7 @@ await this.ClientWebSocket.ConnectAsync(mAddressUri, mCancellationToken)
             catch (Exception ex)
             {
                 RaiseConnectionError(ex);
-                RaiseConnectionClosed();
+                await RaiseConnectionClosed().ConfigureAwait(false);
             }
 
             return false;
@@ -134,7 +134,7 @@ data is very small.
                 await CloseWebSocket().ConfigureAwait(false);
             }
 
-            RaiseConnectionClosed();
+            await RaiseConnectionClosed().ConfigureAwait(false);
         }
 
         private async Task CloseWebSocket()

src/netstandard/WampSharp/Core/Listener/Connections/AsyncConnection/AsyncWampConnection.cs

@@ -7,7 +7,7 @@
 
 namespace WampSharp.Core.Listener
 {
-    public abstract class AsyncWampConnection<TMessage> : IWampConnection<TMessage>,
+    public abstract class AsyncWampConnection<TMessage> : IAsyncWampConnection<TMessage>,
         IAsyncDisposable
     {
         private readonly ActionBlock<WampMessage<object>> mSendBlock;
@@ -56,7 +56,14 @@ protected async Task InnerSend(WampMessage<object> message)
 
         public event EventHandler ConnectionOpen;
         public event EventHandler<WampMessageArrivedEventArgs<TMessage>> MessageArrived;
-        public event EventHandler ConnectionClosed;
+        public event AsyncEventHandler<EventArgs> ConnectionClosedAsync;
+        
+        public event EventHandler ConnectionClosed
+        {
+            add => ConnectionClosedAsync += value.ConvertToAsync();
+            remove => ConnectionClosedAsync -= value.ConvertToAsync();
+        }
+
         public event EventHandler<WampConnectionErrorEventArgs> ConnectionError;
         protected abstract Task SendAsync(WampMessage<object> message);
 
@@ -70,10 +77,10 @@ protected virtual void RaiseMessageArrived(WampMessage<TMessage> message)
             MessageArrived?.Invoke(this, new WampMessageArrivedEventArgs<TMessage>(message));
         }
 
-        protected virtual void RaiseConnectionClosed()
+        protected virtual async Task RaiseConnectionClosed()
         {
             mLogger.Debug("Connection has been closed");
-            ConnectionClosed?.Invoke(this, EventArgs.Empty);
+            await ConnectionClosedAsync?.InvokeAsync(this, EventArgs.Empty);
         }
 
         protected virtual void RaiseConnectionError(Exception ex)

src/netstandard/WampSharp/Core/Listener/Connections/IWampConnection.cs

@@ -48,4 +48,18 @@ public interface IWampConnection<TMessage> : IDisposable
         /// </summary>
         event EventHandler<WampConnectionErrorEventArgs> ConnectionError;
     }
+
+
+    /// <summary>
+    /// A <see cref="IWampConnection{TMessage}"/> with async features
+    /// </summary>
+    /// <typeparam name="TMessage"></typeparam>
+    internal interface IAsyncWampConnection<TMessage> : IWampConnection<TMessage>,
+                                                        IAsyncDisposable
+    {
+        /// <summary>
+        /// Occurs when this connection closes.
+        /// </summary>
+        event AsyncEventHandler<EventArgs> ConnectionClosedAsync;
+    }
 }

src/netstandard/WampSharp/Core/Listener/Connections/ReviveClientConnection.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using WampSharp.Core.Message;
 
 namespace WampSharp.Core.Listener
@@ -28,13 +29,28 @@ private IControlledWampConnection<TMessage> SetupConnection()
             IControlledWampConnection<TMessage> result = mFactory();
 
             result.ConnectionOpen += OnConnectionOpen;
-            result.ConnectionClosed += OnConnectionClosed;
             result.ConnectionError += OnConnectionError;
             result.MessageArrived += OnMessageArrived;
 
+            if (result is IAsyncWampConnection<TMessage> asyncWampConnection)
+            {
+                asyncWampConnection.ConnectionClosedAsync += OnConnectionClosedAsync;
+            }
+            else
+            {
+                result.ConnectionClosed += OnConnectionClosed;
+            }
+
             return result;
         }
 
+        private async Task OnConnectionClosedAsync(object sender, EventArgs e)
+        {
+            await DestroyConnectionAsync().ConfigureAwait(false);
+
+            RaiseConnectionClosed();
+        }
+
         private void OnMessageArrived(object sender, WampMessageArrivedEventArgs<TMessage> e)
         {
             RaiseMessageArrived(e);
@@ -52,17 +68,33 @@ private void OnConnectionClosed(object sender, EventArgs e)
             RaiseConnectionClosed();
         }
 
+        private async Task DestroyConnectionAsync()
+        {
+            UnwireEvents();
+            IAsyncWampConnection<TMessage> connection = mConnection as IAsyncWampConnection<TMessage>;
+
+            connection.ConnectionClosedAsync -= OnConnectionClosedAsync;
+            await connection.DisposeAsync().ConfigureAwait(false);
+
+            mConnection = null;
+        }
+
         private void DestroyConnection()
         {
-            mConnection.ConnectionOpen -= OnConnectionOpen;
-            mConnection.ConnectionClosed -= OnConnectionClosed;
-            mConnection.ConnectionError -= OnConnectionError;
-            mConnection.MessageArrived -= OnMessageArrived;
+            UnwireEvents();
 
             mConnection.Dispose();
             mConnection = null;
         }
 
+        private void UnwireEvents()
+        {
+            mConnection.ConnectionOpen -= OnConnectionOpen;
+            mConnection.ConnectionError -= OnConnectionError;
+            mConnection.MessageArrived -= OnMessageArrived;
+            mConnection.ConnectionClosed -= OnConnectionClosed;
+        }
+
         private void OnConnectionOpen(object sender, EventArgs e)
         {
             RaiseConnectionOpen();

src/netstandard/WampSharp/Core/Utilities/AsyncEventHandler.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WampSharp.Core
+{
+    public delegate Task AsyncEventHandler<in TEventArgs>(object sender, TEventArgs e) where TEventArgs : EventArgs;
+
+    public static class AsyncEventHandlerExtensions
+    {
+        public static async Task InvokeAsync<TEventArgs>(this AsyncEventHandler<TEventArgs> handler, object sender,
+                                                         TEventArgs e) where TEventArgs : EventArgs
+        {
+            if (handler == null)
+            {
+                throw new ArgumentNullException(nameof(handler));
+            }
+
+            Delegate[] invocationList = handler.GetInvocationList();
+
+            foreach (AsyncEventHandler<TEventArgs> currentSubscriber in invocationList
+                .Cast<AsyncEventHandler<TEventArgs>>())
+            {
+                await currentSubscriber(sender, e).ConfigureAwait(false);
+            }
+        }
+
+        public static AsyncEventHandler<EventArgs> ConvertToAsync
+            (this EventHandler handler)
+        {
+            if (handler == null)
+            {
+                throw new ArgumentNullException(nameof(handler));
+            }
+
+            return (sender, args) =>
+                   {
+                       handler(sender, args);
+                       return Task.CompletedTask;
+                   };
+        }
+
+
+        public static AsyncEventHandler<TEventArgs> ConvertToAsync<TEventArgs>
+            (this EventHandler<TEventArgs> handler) where TEventArgs : EventArgs
+        {
+            if (handler == null)
+            {
+                throw new ArgumentNullException(nameof(handler));
+            }
+
+            return (sender, args) =>
+                   {
+                       handler(sender, args);
+                       return Task.CompletedTask;
+                   };
+        }
+    }
+}