Squashed commit of the following:

commit 1ca93ce870468c7effcc69a05b1675f855598f3e
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Aug 12 13:44:03 2021 +0200

    Version 4.0.0 release

commit f8cefe72cae8b845aa995d16415f160228f5dfc4
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Aug 9 11:46:50 2021 +0200

    Fix for processing a duplicate message in symbol order book

commit f3573e414f80ea622caadb38f9e020f2eab7c834
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Aug 9 11:36:50 2021 +0200

    Updated version

commit 170a3b5c83cd500f0adb5cf74eaaa9c1a8674a10
Merge: 73a0e2c 0d43f6e
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Aug 9 11:33:59 2021 +0200

    Merge branch 'feature/replace-websocket4net' of https://github.com/JKorf/CryptoExchange.Net into feature/replace-websocket4net

commit 73a0e2cb62f8d51b4b8fe1b29fbf16f07ebf13e0
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Aug 9 11:33:45 2021 +0200

    Fixed processing issue in SymbolOrderBook

commit 0d43f6e14e9b61af9bb3250fd72559a5fbf5300a
Author: Jan Korf <jankorf91@gmail.com>
Date:   Sat Jul 31 14:48:23 2021 +0200

    Updated version

commit 037d765fc73740d2aa2159bce6d57f01d989bdc2
Author: Jan Korf <jankorf91@gmail.com>
Date:   Sat Jul 31 11:14:42 2021 +0200

    Socket fixes

commit 13cf3e27b9e91b252368a5dc799363111eed9148
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jul 26 09:55:51 2021 +0200

    Updated version

commit 333c6c4207cafbfd09b37743fb36008f87939666
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jul 26 09:50:35 2021 +0200

    Update CryptoExchangeWebSocketClient.cs

commit ad2b6284b042cfa846e55f8b5f53b2397039dff7
Merge: 64bdcdf 2591cc6
Author: Jan Korf <jankorf91@gmail.com>
Date:   Sun Jul 25 22:44:49 2021 +0200

    Merge branch 'feature/replace-websocket4net' of https://github.com/jkorf/CryptoExchange.Net into feature/replace-websocket4net

commit 64bdcdf087d56b8470baedac1ac86d263ad72490
Author: Jan Korf <jankorf91@gmail.com>
Date:   Sun Jul 25 22:44:03 2021 +0200

    Fix for deadlock

commit 2591cc6782e281595c436ccb4b74a9c7c7f5dc57
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Jul 15 15:10:08 2021 +0200

    Cleanup

commit b3b6235b6edf0ea1a6437239919666d08c274129
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Jul 9 16:14:33 2021 +0200

    Updated version

commit 12975fd13f7884382fea608d774b1e0ac384cb70
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Jul 9 16:12:04 2021 +0200

    Async postfix for order book methods

commit d49d59094e18c83de994a1b591f906f7efe916c5
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Jul 9 15:47:38 2021 +0200

    Renamed async methods with Async post fixes

commit cbe103930ab90378507780cb150596abcb15eb3f
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Jul 8 09:29:34 2021 +0200

    Added Book property on SymbolOrderBook

commit ecc101aed11bab73c49fadc93d3ca4607094d92a
Merge: 181f942 a172461
Author: Jan Korf <jankorf91@gmail.com>
Date:   Wed Jul 7 23:38:58 2021 +0200

    Merge branch 'feature/replace-websocket4net' of https://github.com/jkorf/CryptoExchange.Net into feature/replace-websocket4net

commit 181f942e2137ff5dfede5365012e24dfb2f07cf9
Author: Jan Korf <jankorf91@gmail.com>
Date:   Wed Jul 7 23:38:49 2021 +0200

    Added CalculateAverageFillPrice to order book

commit a17246153df463aa881e9808ffb87fa25f144d90
Author: Jkorf <jankorf91@gmail.com>
Date:   Wed Jul 7 13:11:39 2021 +0200

    Updated version

commit c60f138ae846a991662e7544d45845decd25cc10
Author: Jkorf <jankorf91@gmail.com>
Date:   Wed Jul 7 13:05:44 2021 +0200

    Fix not logging responses with LogLevel.Debug

commit 91f168fd25150b3048346bcc6acc549ee3685e50
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jul 5 10:39:48 2021 +0200

    Added ExchangeHelpers to ReadMe

commit ff6c02e574d3f8a270e2960fdda0222c53457868
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jul 5 10:34:25 2021 +0200

    Added some helper methods, some code comments

commit 55900a3db938f032436303c2399f41b7a3a5fef1
Merge: 9067a8a 7ab6bb0
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jul 5 09:24:43 2021 +0200

    Merge branch 'master' into feature/replace-websocket4net

commit 9067a8a82c5d8c1e1f6ba0f2600539efd7f1a122
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Jul 2 16:03:38 2021 +0200

    Update README.md

commit 0f202d69c7e3db71f66dcfef5673b97f56451a40
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Jun 25 16:37:06 2021 +0200

    Code comments, added console logger

commit 52160c6dc1bbaca3cc498c49ec0dd71310d5102b
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Jun 24 16:47:04 2021 +0200

    Added/cleaned up code comments

commit 95771c5c4ae3a74963fea5a01e05559596b1b39d
Author: Jkorf <jankorf91@gmail.com>
Date:   Tue Jun 22 14:22:15 2021 +0200

    Additional info socket connection error

commit 6a90e2316d54d42c0f5b7772d60d4861ff340c5a
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Jun 17 16:10:43 2021 +0200

    Updated version

commit b138c1050372b5d5fbdc3b2a33d3c09b677a669a
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Jun 17 16:08:19 2021 +0200

    Fix not receiving OriginalData in output

commit 462f44cf45e1bc7ee333e37ad0a778185d84fa58
Author: Jan Korf <jankorf91@gmail.com>
Date:   Wed Jun 16 22:35:03 2021 +0200

    Fix invalidoperation in order book

commit aa7414321b1297487a5133fa0a7e5ede059a6939
Author: Jan Korf <jankorf91@gmail.com>
Date:   Sun Jun 13 20:56:01 2021 +0200

    logging no data task

commit 22aa5928f5cb11ac5877bc4c606d64550aad3f0c
Author: Jan Korf <jankorf91@gmail.com>
Date:   Tue Jun 8 19:13:18 2021 +0200

    Updated version

commit 1ceb22994a5cdf779de8890e39101956728ab80c
Author: Jan Korf <jankorf91@gmail.com>
Date:   Tue Jun 8 19:11:20 2021 +0200

    Fixed exception on .net framework when creating socket

commit 971cab739dd543de0122c9bc12819f57d4df15e3
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jun 7 14:41:27 2021 +0200

    Updated unit test packages

commit 216213d5ad0e14c6cd7b8e22131b8b07338bacfc
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon Jun 7 10:46:57 2021 +0200

    Updated version

commit ce2c7ddc182599c5ca9ef0eb64e14906c8b734e1
Merge: b219705 55aa77e
Author: Jan Korf <jankorf91@gmail.com>
Date:   Mon Jun 7 09:29:57 2021 +0200

    Merge pull request #96 from ridicoulous/master

    iexchange client improvements

commit b21970552602eb853a061034a5c223a381e7465b
Author: Jkorf <jankorf91@gmail.com>
Date:   Tue Jun 1 14:55:02 2021 +0200

    Updated version

commit dd2cf84c163920e545ec09e1b0d29ab295f2fbe2
Author: Jkorf <jankorf91@gmail.com>
Date:   Tue Jun 1 14:52:55 2021 +0200

    Added tests for LogLevel null

commit 975003284f53094750ec3d4a608d814a6d70f745
Author: Jkorf <jankorf91@gmail.com>
Date:   Tue Jun 1 14:42:59 2021 +0200

    Made LogLevel nullable in options, moved log formatting to the ILogger implementation

commit 1c1de5651e31e9288b4fd125b0545efbfa9098f7
Merge: 34bf986 e7838ab
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon May 31 10:16:52 2021 +0200

    Merge branch 'feature/replace-websocket4net' of https://github.com/JKorf/CryptoExchange.Net into feature/replace-websocket4net

commit 34bf9867dcd2c2b195079094560351d0db2dac0f
Author: Jkorf <jankorf91@gmail.com>
Date:   Mon May 31 10:16:49 2021 +0200

    fixed some axync issues

commit e7838ab9e8310b4ae02c172f0a764aad8ca8fd4e
Author: Jan Korf <jankorf91@gmail.com>
Date:   Wed May 26 13:46:40 2021 +0200

    Added Discord link to ReadMe

commit 502939f57cf8deac1809c4bd2c63af4acc62bd43
Author: Jan Korf <jankorf91@gmail.com>
Date:   Wed May 26 11:12:59 2021 +0200

    Updated version

commit 92b745ca291259eb246572c8029709b87ddbf2d3
Author: Jan Korf <jankorf91@gmail.com>
Date:   Tue May 25 21:52:47 2021 +0200

    Refactored logging to use ILogger

commit b4904b5e4a239ffb29f00b13a314fea33d45d9cb
Author: Jan Korf <jankorf91@gmail.com>
Date:   Tue May 25 14:07:01 2021 +0200

    Added optional json output, added DataEvent for socket updates

commit 55aa77e926
Author: Artem Kurianov <artemkuryanov@gmail.com>
Date:   Fri May 14 13:11:05 2021 +0000

    added order time

commit efe70445ed
Author: Artem Kurianov <artemkuryanov@gmail.com>
Date:   Fri May 14 13:08:58 2021 +0000

    iexchange client improvements

commit 8f0943f0f0469b42f40334257f0f3ca5e39e3bd9
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu May 6 10:24:33 2021 +0200

    Updated version

commit 17d1e5f71bd1986eea0e8273da070f3615d3e378
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu May 6 10:01:24 2021 +0200

    Added missing configureawaits

commit ed748aa474e0d52a78bc15b9b0aa0a9b4d8dd35e
Author: Jan Korf <jankorf91@gmail.com>
Date:   Fri Apr 30 23:00:07 2021 +0200

    Updated version

commit 1ae545563497889c75ed6183377e759da5beed61
Author: Jan Korf <jankorf91@gmail.com>
Date:   Fri Apr 30 21:00:40 2021 +0200

    Updated socket closing

commit 8243ad60dc64f96ed262ec54cbd6c55553c056be
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Apr 30 15:48:36 2021 +0200

    Updated version

commit 4299f238f3debc2b1b062eb7cde195a3d64dbdfc
Author: Jan Korf <jankorf91@gmail.com>
Date:   Fri Apr 30 15:44:32 2021 +0200

    Fix for closing socket without timeout task

commit 71f49cfe5142cb70fb651936e74b8eef5b7350d4
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Apr 30 14:59:10 2021 +0200

    Updated version

commit 5d669068ec0a7241daef383c6867c2e22ec21ed3
Author: Jkorf <jankorf91@gmail.com>
Date:   Fri Apr 30 14:56:15 2021 +0200

    Renaming, cleanup

    handler -> subscription
    socket (SocketConnection) -> socketConnection

commit 0fa13e286060cd3b96b808406434092c0e89e89d
Author: Jkorf <jankorf91@gmail.com>
Date:   Thu Apr 29 16:20:41 2021 +0200

    Initial work replacing Websocket4Net with ClientWebSocket

CryptoExchange.Net/Sockets/SocketConnection.cs

@@ -8,6 +8,7 @@ using System.Threading.Tasks;
 using CryptoExchange.Net.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.Sockets
 {
@@ -42,12 +43,12 @@ namespace CryptoExchange.Net.Sockets
         public event Action<JToken>? UnhandledMessage;
 
         /// <summary>
-        /// The amount of handlers
+        /// The amount of subscriptions on this connection
         /// </summary>
-        public int HandlerCount
+        public int SubscriptionCount
         {
-            get { lock (handlersLock)
-                return handlers.Count(h => h.UserSubscription); }
+            get { lock (subscriptionLock)
+                return subscriptions.Count(h => h.UserSubscription); }
         }
 
         /// <summary>
@@ -60,11 +61,11 @@ namespace CryptoExchange.Net.Sockets
         public bool Connected { get; private set; }
 
         /// <summary>
-        /// The socket
+        /// The underlying socket
         /// </summary>
         public IWebsocket Socket { get; set; }
         /// <summary>
-        /// If should reconnect upon closing
+        /// If the socket should be reconnected upon closing
         /// </summary>
         public bool ShouldReconnect { get; set; }
 
@@ -84,7 +85,7 @@ namespace CryptoExchange.Net.Sockets
                 if (pausedActivity != value)
                 {
                     pausedActivity = value;
-                    log.Write(LogVerbosity.Debug, "Paused activity: " + value);
+                    log.Write(LogLevel.Debug, "Paused activity: " + value);
                     if(pausedActivity) ActivityPaused?.Invoke();
                     else ActivityUnpaused?.Invoke();
                 }
@@ -92,8 +93,8 @@ namespace CryptoExchange.Net.Sockets
         }
 
         private bool pausedActivity;
-        private readonly List<SocketSubscription> handlers;
-        private readonly object handlersLock = new object();
+        private readonly List<SocketSubscription> subscriptions;
+        private readonly object subscriptionLock = new object();
 
         private bool lostTriggered;
         private readonly Log log;
@@ -113,7 +114,7 @@ namespace CryptoExchange.Net.Sockets
 
             pendingRequests = new List<PendingRequest>();
 
-            handlers = new List<SocketSubscription>();
+            subscriptions = new List<SocketSubscription>();
             Socket = socket;
 
             Socket.Timeout = client.SocketNoDataTimeout;
@@ -137,9 +138,14 @@ namespace CryptoExchange.Net.Sockets
             };
         }
         
+        /// <summary>
+        /// Process a message received by the socket
+        /// </summary>
+        /// <param name="data"></param>
         private void ProcessMessage(string data)
         {
-            log.Write(LogVerbosity.Debug, $"Socket {Socket.Id} received data: " + data);
+            var timestamp = DateTime.UtcNow;
+            log.Write(LogLevel.Trace, $"Socket {Socket.Id} received data: " + data);
             if (string.IsNullOrEmpty(data)) return;
 
             var tokenData = data.ToJToken(log);
@@ -151,12 +157,14 @@ namespace CryptoExchange.Net.Sockets
                     return;
             }
 
+            var messageEvent = new MessageEvent(this, tokenData, socketClient.OutputOriginalData ? data: null, timestamp);
             var handledResponse = false;
             PendingRequest[] requests;
             lock(pendingRequests)
 			{
                 requests = pendingRequests.ToArray();
 			}
+            // Check if this message is an answer on any pending requests
             foreach (var pendingRequest in requests)
             {
                 if (pendingRequest.Check(tokenData))
@@ -176,51 +184,54 @@ namespace CryptoExchange.Net.Sockets
                 }
             }
             
-            if (!HandleData(tokenData) && !handledResponse)
+            // Message was not a request response, check data handlers
+            if (!HandleData(messageEvent) && !handledResponse)
             {
                 if (!socketClient.UnhandledMessageExpected)
-                    log.Write(LogVerbosity.Warning, "Message not handled: " + tokenData);
+                    log.Write(LogLevel.Warning, $"Socket {Socket.Id} Message not handled: " + tokenData);
                 UnhandledMessage?.Invoke(tokenData);
             }
         }
 
         /// <summary>
-        /// Add handler
+        /// Add subscription to this connection
         /// </summary>
-        /// <param name="handler"></param>
-        public void AddHandler(SocketSubscription handler)
+        /// <param name="subscription"></param>
+        public void AddSubscription(SocketSubscription subscription)
         {
-            lock(handlersLock)
-                handlers.Add(handler);
+            lock(subscriptionLock)
+                subscriptions.Add(subscription);
         }
 
-        private bool HandleData(JToken tokenData)
+        private bool HandleData(MessageEvent messageEvent)
         {
             SocketSubscription? currentSubscription = null;
             try
             { 
                 var handled = false;
                 var sw = Stopwatch.StartNew();
-                lock (handlersLock)
+
+                // Loop the subscriptions to check if any of them signal us that the message is for them
+                lock (subscriptionLock)
                 {
-                    foreach (var handler in handlers.ToList())
+                    foreach (var subscription in subscriptions.ToList())
                     {
-                        currentSubscription = handler;
-                        if (handler.Request == null)
+                        currentSubscription = subscription;
+                        if (subscription.Request == null)
                         {
-                            if (socketClient.MessageMatchesHandler(tokenData, handler.Identifier!))
+                            if (socketClient.MessageMatchesHandler(messageEvent.JsonData, subscription.Identifier!))
                             {
                                 handled = true;
-                                handler.MessageHandler(this, tokenData);
+                                subscription.MessageHandler(messageEvent);
                             }
                         }
                         else
                         {
-                            if (socketClient.MessageMatchesHandler(tokenData, handler.Request))
+                            if (socketClient.MessageMatchesHandler(messageEvent.JsonData, subscription.Request))
                             {
                                 handled = true;
-                                tokenData = socketClient.ProcessTokenData(tokenData);
-                                handler.MessageHandler(this, tokenData);
+                                messageEvent.JsonData = socketClient.ProcessTokenData(messageEvent.JsonData);
+                                subscription.MessageHandler(messageEvent);
                             }
                         }
                     }
@@ -228,29 +239,29 @@ namespace CryptoExchange.Net.Sockets
 
                 sw.Stop();
                 if (sw.ElapsedMilliseconds > 500)
-                    log.Write(LogVerbosity.Warning, $"Socket {Socket.Id} message processing slow ({sw.ElapsedMilliseconds}ms), consider offloading data handling to another thread. " +
+                    log.Write(LogLevel.Warning, $"Socket {Socket.Id} message processing slow ({sw.ElapsedMilliseconds}ms), consider offloading data handling to another thread. " +
                                                     "Data from this socket may arrive late or not at all if message processing is continuously slow.");
                 else
-                    log.Write(LogVerbosity.Debug, $"Socket {Socket.Id} message processed in {sw.ElapsedMilliseconds}ms");
+                    log.Write(LogLevel.Trace, $"Socket {Socket.Id} message processed in {sw.ElapsedMilliseconds}ms");
                 return handled;
             }
             catch (Exception ex)
             {
-                log.Write(LogVerbosity.Error, $"Socket {Socket.Id} Exception during message processing\r\nException: {ex}\r\nData: {tokenData}");
+                log.Write(LogLevel.Error, $"Socket {Socket.Id} Exception during message processing\r\nException: {ex.ToLogString()}\r\nData: {messageEvent.JsonData}");
                 currentSubscription?.InvokeExceptionHandler(ex);
                 return false;
             }
         }
 
         /// <summary>
-        /// Send data
+        /// Send data and wait for an answer
         /// </summary>
-        /// <typeparam name="T">The data type</typeparam>
+        /// <typeparam name="T">The data type expected in response</typeparam>
         /// <param name="obj">The object to send</param>
         /// <param name="timeout">The timeout for response</param>
         /// <param name="handler">The response handler</param>
         /// <returns></returns>
-        public virtual Task SendAndWait<T>(T obj, TimeSpan timeout, Func<JToken, bool> handler)
+        public virtual Task SendAndWaitAsync<T>(T obj, TimeSpan timeout, Func<JToken, bool> handler)
         {
             var pending = new PendingRequest(handler, timeout);
             lock (pendingRequests)
@@ -262,7 +273,7 @@ namespace CryptoExchange.Net.Sockets
         }
 
         /// <summary>
-        /// Send data to the websocket
+        /// Send data over the websocket connection
         /// </summary>
         /// <typeparam name="T">The type of the object to send</typeparam>
         /// <param name="obj">The object to send</param>
@@ -276,12 +287,12 @@ namespace CryptoExchange.Net.Sockets
         }
 
         /// <summary>
-        /// Send string data to the websocket
+        /// Send string data over the websocket connection
         /// </summary>
         /// <param name="data">The data to send</param>
         public virtual void Send(string data)
         {
-            log.Write(LogVerbosity.Debug, $"Socket {Socket.Id} sending data: {data}");
+            log.Write(LogLevel.Debug, $"Socket {Socket.Id} sending data: {data}");
             Socket.Send(data);
         }
 
@@ -297,11 +308,12 @@ namespace CryptoExchange.Net.Sockets
 
                 Socket.Reconnecting = true;
 
-                log.Write(LogVerbosity.Info, $"Socket {Socket.Id} Connection lost, will try to reconnect after {socketClient.ReconnectInterval}");
+                log.Write(LogLevel.Information, $"Socket {Socket.Id} Connection lost, will try to reconnect after {socketClient.ReconnectInterval}");
                 Task.Run(async () =>
                 {
                     while (ShouldReconnect)
                     {
+                        // Wait a bit before attempting reconnect
                         await Task.Delay(socketClient.ReconnectInterval).ConfigureAwait(false);
                         if (!ShouldReconnect)
                         {
@@ -311,20 +323,21 @@ namespace CryptoExchange.Net.Sockets
                         }
 
                         Socket.Reset();
-                        if (!await Socket.Connect().ConfigureAwait(false))
+                        if (!await Socket.ConnectAsync().ConfigureAwait(false))
                         {
-                            log.Write(LogVerbosity.Debug, $"Socket {Socket.Id} failed to reconnect");
+                            log.Write(LogLevel.Debug, $"Socket {Socket.Id} failed to reconnect");
                             continue;
                         }
 
+                        // Successfully reconnected
                         var time = DisconnectTime;
                         DisconnectTime = null;
 
-                        log.Write(LogVerbosity.Info, $"Socket {Socket.Id} reconnected after {DateTime.UtcNow - time}");
+                        log.Write(LogLevel.Information, $"Socket {Socket.Id} reconnected after {DateTime.UtcNow - time}");
 
-                        var reconnectResult = await ProcessReconnect().ConfigureAwait(false);
+                        var reconnectResult = await ProcessReconnectAsync().ConfigureAwait(false);
                         if (!reconnectResult)
-                            await Socket.Close().ConfigureAwait(false);
+                            await Socket.CloseAsync().ConfigureAwait(false);
                         else
                         {
                             if (lostTriggered)
@@ -342,11 +355,11 @@ namespace CryptoExchange.Net.Sockets
             }
             else
             {
-                log.Write(LogVerbosity.Info, $"Socket {Socket.Id} closed");
+                // No reconnecting needed
+                log.Write(LogLevel.Information, $"Socket {Socket.Id} closed");
                 if (socketClient.sockets.ContainsKey(Socket.Id))
                     socketClient.sockets.TryRemove(Socket.Id, out _);
 
-                Socket.Dispose();
                 Closed?.Invoke();
             }
         }
@@ -356,29 +369,32 @@ namespace CryptoExchange.Net.Sockets
             await Task.Run(() => ConnectionRestored?.Invoke(disconnectTime.HasValue ? DateTime.UtcNow - disconnectTime.Value : TimeSpan.FromSeconds(0))).ConfigureAwait(false);
         }
 
-        private async Task<bool> ProcessReconnect()
+        private async Task<bool> ProcessReconnectAsync()
         {
             if (Authenticated)
             {
-                var authResult = await socketClient.AuthenticateSocket(this).ConfigureAwait(false);
+                // If we reconnected a authenticated connection we need to re-authenticate
+                var authResult = await socketClient.AuthenticateSocketAsync(this).ConfigureAwait(false);
                 if (!authResult)
                 {
-                    log.Write(LogVerbosity.Info, "Authentication failed on reconnected socket. Disconnecting and reconnecting.");
+                    log.Write(LogLevel.Information, $"Socket {Socket.Id} authentication failed on reconnected socket. Disconnecting and reconnecting.");
                     return false;
                 }
 
-                log.Write(LogVerbosity.Debug, "Authentication succeeded on reconnected socket.");
+                log.Write(LogLevel.Debug, $"Socket {Socket.Id} authentication succeeded on reconnected socket.");
             }
 
-            List<SocketSubscription> handlerList;
-            lock (handlersLock)
-                handlerList = handlers.Where(h => h.Request != null).ToList();
+            // Get a list of all subscriptions on the socket
+            List<SocketSubscription> subscriptionList;
+            lock (subscriptionLock)
+                subscriptionList = subscriptions.Where(h => h.Request != null).ToList();
 
             var success = true;
             var taskList = new List<Task>();
-            foreach (var handler in handlerList)
+            // Foreach subscription which is subscribed by a subscription request we will need to resend that request to resubscribe
+            foreach (var subscription in subscriptionList)
             {
-                var task = socketClient.SubscribeAndWait(this, handler.Request!, handler).ContinueWith(t =>
+                var task = socketClient.SubscribeAndWaitAsync(this, subscription.Request!, subscription).ContinueWith(t =>
                 {
                     if (!t.Result)
                         success = false;
@@ -386,14 +402,14 @@ namespace CryptoExchange.Net.Sockets
                 taskList.Add(task);
             }
 
-            Task.WaitAll(taskList.ToArray());
+            await Task.WhenAll(taskList).ConfigureAwait(false);
             if (!success)
             {
-                log.Write(LogVerbosity.Debug, "Resubscribing all subscriptions failed on reconnected socket. Disconnecting and reconnecting.");
+                log.Write(LogLevel.Debug, $"Socket {Socket.Id} resubscribing all subscriptions failed on reconnected socket. Disconnecting and reconnecting.");
                 return false;
             }
 
-            log.Write(LogVerbosity.Debug, "All subscription successfully resubscribed on reconnected socket.");
+            log.Write(LogLevel.Debug, $"Socket {Socket.Id} all subscription successfully resubscribed on reconnected socket.");
             return true;
         }
         
@@ -401,36 +417,39 @@ namespace CryptoExchange.Net.Sockets
         /// Close the connection
         /// </summary>
         /// <returns></returns>
-        public async Task Close()
+        public async Task CloseAsync()
         {
             Connected = false;
             ShouldReconnect = false;
             if (socketClient.sockets.ContainsKey(Socket.Id))
                 socketClient.sockets.TryRemove(Socket.Id, out _);
             
-            await Socket.Close().ConfigureAwait(false);
+            await Socket.CloseAsync().ConfigureAwait(false);
             Socket.Dispose();
         }
 
         /// <summary>
-        /// Close the subscription
+        /// Close a subscription on this connection. If all subscriptions on this connection are closed the connection gets closed as well
         /// </summary>
         /// <param name="subscription">Subscription to close</param>
         /// <returns></returns>
-        public async Task Close(SocketSubscription subscription)
+        public async Task CloseAsync(SocketSubscription subscription)
         {
+            if (!Socket.IsOpen)
+                return;
+
             if (subscription.Confirmed)
-                await socketClient.Unsubscribe(this, subscription).ConfigureAwait(false);
+                await socketClient.UnsubscribeAsync(this, subscription).ConfigureAwait(false);
 
-            var shouldCloseWrapper = false;
-            lock (handlersLock)
-                shouldCloseWrapper = handlers.Count(r => r.UserSubscription && subscription != r) == 0;
+            var shouldCloseConnection = false;
+            lock (subscriptionLock)
+                shouldCloseConnection = !subscriptions.Any(r => r.UserSubscription && subscription != r);
 
-            if (shouldCloseWrapper)
-                await Close().ConfigureAwait(false);
+            if (shouldCloseConnection)
+                await CloseAsync().ConfigureAwait(false);
 
-            lock (handlersLock)            
-                handlers.Remove(subscription);            
+            lock (subscriptionLock)
+                subscriptions.Remove(subscription);            
         }
     }