Replaced "int TimeOut" by "TimeSpan Timeout" and other improvements

theSlyest · theSlyest · commit 871f015bccb8 · 2025-08-29T15:20:38.000Z
diff --git a/Parse/Abstractions/Infrastructure/ILiveQueryServerConnectionData.cs b/Parse/Abstractions/Infrastructure/ILiveQueryServerConnectionData.cs
@@ -1,17 +1,19 @@
-﻿namespace Parse.Abstractions.Infrastructure;
+﻿using System;
+
+namespace Parse.Abstractions.Infrastructure;
 
 public interface ILiveQueryServerConnectionData : IServerConnectionData
 {
     /// <summary>
     /// Represents the default timeout duration, in milliseconds.
     /// </summary>
-    public const int DefaultTimeOut = 5000; // 5 seconds
+    public static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(5);
 
     /// <summary>
     /// The timeout duration, in milliseconds, used for various operations, such as
     /// establishing a connection or completing a subscription.
     /// </summary>
-    int TimeOut { get; set; }
+    TimeSpan Timeout { get; set; }
 
     /// <summary>
     /// The default buffer size, in bytes.
diff --git a/Parse/Infrastructure/Execution/MessageReceivedEventArgs.cs b/Parse/Infrastructure/Execution/MessageReceivedEventArgs.cs
@@ -10,5 +10,5 @@ public class MessageReceivedEventArgs(string message) : EventArgs
     /// <summary>
     /// Gets the message content that was received.
     /// </summary>
-    public string Message { get; } = message;
+    public string Message { get; } = message ?? throw new ArgumentNullException(nameof(message));
 }
diff --git a/Parse/Infrastructure/Execution/TextWebSocketClient.cs b/Parse/Infrastructure/Execution/TextWebSocketClient.cs
@@ -13,7 +13,7 @@ namespace Parse.Infrastructure.Execution;
 /// Represents a WebSocket client that allows connecting to a WebSocket server, sending messages, and receiving messages.
 /// Implements the <c>IWebSocketClient</c> interface for WebSocket operations.
 /// </summary>
-class TextWebSocketClient(int bufferSize) : IWebSocketClient
+class TextWebSocketClient(int bufferSize) : IWebSocketClient, IDisposable
 {
     /// <summary>
     /// A private instance of the ClientWebSocket class used to manage the WebSocket connection.
@@ -68,7 +68,7 @@ public async Task OpenAsync(string serverUri, CancellationToken cancellationToke
                 webSocketToConnect = webSocket;
             }
         }
-
+        listeningCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
         if (webSocketToConnect is not null)
         {
             await webSocketToConnect.ConnectAsync(new Uri(serverUri), cancellationToken);
@@ -86,10 +86,7 @@ public async Task OpenAsync(string serverUri, CancellationToken cancellationToke
     /// </returns>
     public async Task CloseAsync(CancellationToken cancellationToken = default)
     {
-        if (webSocket is not null)
-        {
-            await webSocket?.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken)!;
-        }
+        await webSocket?.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken)!;
     }
 
     private async Task ListenForMessages(CancellationToken cancellationToken)
@@ -107,7 +104,6 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
 
                 if (result.MessageType == WebSocketMessageType.Close)
                 {
-                    await CloseAsync(cancellationToken);
                     break;
                 }
 
@@ -118,17 +114,17 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
                 }
                 else
                 {
-                    // Handle partial messages by accumulating data until EndOfMessage is true
-                    StringBuilder messageBuilder = new StringBuilder();
-                    messageBuilder.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
+                    // Accumulate bytes to handle UTF-8 characters split across boundaries
+                    using var messageStream = new MemoryStream();
+                    messageStream.Write(buffer, 0, result.Count);
                     while (!result.EndOfMessage)
                     {
                         result = await webSocket.ReceiveAsync(
                             new ArraySegment<byte>(buffer),
                             cancellationToken);
-                        messageBuilder.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
+                        messageStream.Write(buffer, 0, result.Count);
                     }
-                    string fullMessage = messageBuilder.ToString();
+                    string fullMessage = Encoding.UTF8.GetString(messageStream.ToArray());
                     MessageReceived?.Invoke(this, new MessageReceivedEventArgs(fullMessage));
                 }
             }
@@ -206,4 +202,33 @@ public async Task SendAsync(string message, CancellationToken cancellationToken
         }
         await webSocket.SendAsync(Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, cancellationToken);
     }
+
+    private CancellationTokenSource listeningCts;
+    private bool disposed;
+    
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+    
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!disposed)
+        {
+            if (disposing)
+            {
+                listeningCts?.Cancel();
+                try
+                {
+                    listeningTask?.Wait(TimeSpan.FromSeconds(5));
+                }
+                catch { }
+                
+                webSocket?.Dispose();
+                listeningCts?.Dispose();
+            }
+            disposed = true;
+        }
+    }
 }
diff --git a/Parse/Infrastructure/LateInitializedMutableServiceHub.cs b/Parse/Infrastructure/LateInitializedMutableServiceHub.cs
@@ -171,7 +171,7 @@ public IWebSocketClient WebSocketClient
 
     public IParseLiveQueryController LiveQueryController
     {
-        get => LateInitializer.GetValue<IParseLiveQueryController>(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.TimeOut, WebSocketClient, Decoder));
+        get => LateInitializer.GetValue<IParseLiveQueryController>(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.Timeout, WebSocketClient, Decoder));
         set => LateInitializer.SetValue(value);
     }
 
diff --git a/Parse/Infrastructure/LiveQueryServerConnectionData.cs b/Parse/Infrastructure/LiveQueryServerConnectionData.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using Parse.Abstractions.Infrastructure;
 
@@ -16,7 +17,7 @@ public LiveQueryServerConnectionData() { }
     /// The timeout duration, in milliseconds, used for various operations, such as
     /// establishing a connection or completing a subscription.
     /// </summary>
-    public int TimeOut { get; set; } = ILiveQueryServerConnectionData.DefaultTimeOut;
+    public TimeSpan Timeout { get; set; } = ILiveQueryServerConnectionData.DefaultTimeout;
 
     /// <summary>
     /// The buffer size, in bytes, used by the WebSocket client for communication operations.
diff --git a/Parse/Infrastructure/MutableServiceHub.cs b/Parse/Infrastructure/MutableServiceHub.cs
@@ -109,8 +109,11 @@ public MutableServiceHub SetDefaults(IServerConnectionData connectionData = defa
         PushChannelsController ??= new ParsePushChannelsController(CurrentInstallationController);
         InstallationDataFinalizer ??= new ParseInstallationDataFinalizer { };
 
-        WebSocketClient ??= LiveQueryServerConnectionData is null ? null : new TextWebSocketClient(LiveQueryServerConnectionData.MessageBufferSize);
-        LiveQueryController ??= LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.TimeOut, WebSocketClient, Decoder);
+        if (LiveQueryServerConnectionData is not null)
+        {
+            WebSocketClient ??= new TextWebSocketClient(LiveQueryServerConnectionData.MessageBufferSize);
+            LiveQueryController ??= new ParseLiveQueryController(LiveQueryServerConnectionData.Timeout, WebSocketClient, Decoder);
+        }
 
         return this;
     }
diff --git a/Parse/Infrastructure/ServiceHub.cs b/Parse/Infrastructure/ServiceHub.cs
@@ -72,7 +72,7 @@ public class ServiceHub : IServiceHub
     public IParseInstallationDataFinalizer InstallationDataFinalizer => LateInitializer.GetValue(() => new ParseInstallationDataFinalizer { });
 
     public IWebSocketClient WebSocketClient => LateInitializer.GetValue(() => LiveQueryServerConnectionData is null ? null : new TextWebSocketClient(LiveQueryServerConnectionData.MessageBufferSize));
-    public IParseLiveQueryController LiveQueryController => LateInitializer.GetValue(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.TimeOut, WebSocketClient, Decoder));
+    public IParseLiveQueryController LiveQueryController => LateInitializer.GetValue(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.Timeout, WebSocketClient, Decoder));
 
     public bool Reset()
     {
diff --git a/Parse/Platform/LiveQueries/ParseLiveQuery.cs b/Parse/Platform/LiveQueries/ParseLiveQuery.cs
@@ -87,7 +87,11 @@ private ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKeys
     /// </summary>
     /// <param name="watch">The key that should be watched.</param>
     /// <returns>A new query with the additional constraint.</returns>
-    public ParseLiveQuery<T> Watch(string watch) => new(this, new List<string> { watch });
+    public ParseLiveQuery<T> Watch(string watch)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(watch);
+        return new ParseLiveQuery<T>(this, [ watch ]);
+    }
 
     internal IDictionary<string, object> BuildParameters()
     {
diff --git a/Parse/Platform/LiveQueries/ParseLiveQueryController.cs b/Parse/Platform/LiveQueries/ParseLiveQueryController.cs
@@ -43,7 +43,7 @@ public class ParseLiveQueryController : IParseLiveQueryController, IDisposable,
     /// - Unsubscribing from a query.
     /// Ensure that the value is configured appropriately to avoid premature timeout errors in network-dependent processes.
     /// </remarks>
-    private int TimeOut { get; }
+    private TimeSpan Timeout { get; }
 
     /// <summary>
     /// Event triggered when an error occurs during the operation of the ParseLiveQueryController.
@@ -110,19 +110,19 @@ public enum ParseLiveQueryState
     /// <summary>
     /// Initializes a new instance of the <see cref="ParseLiveQueryController"/> class.
     /// </summary>
-    /// <param name="timeOut"></param>
+    /// <param name="timeout"></param>
     /// <param name="webSocketClient">
     /// The <see cref="IWebSocketClient"/> implementation to use for the live query connection.
     /// </param>
     /// <param name="decoder"></param>
     /// <remarks>
     /// This constructor is used to initialize a new instance of the <see cref="ParseLiveQueryController"/> class
     /// </remarks>
-    public ParseLiveQueryController(int timeOut, IWebSocketClient webSocketClient, IParseDataDecoder decoder)
+    public ParseLiveQueryController(TimeSpan timeout, IWebSocketClient webSocketClient, IParseDataDecoder decoder)
     {
         WebSocketClient = webSocketClient ?? throw new ArgumentNullException(nameof(webSocketClient));
         Decoder = decoder ?? throw new ArgumentNullException(nameof(decoder));
-        TimeOut = timeOut;
+        Timeout = timeout;
         _state = ParseLiveQueryState.Closed;
     }
 
@@ -360,17 +360,24 @@ private async Task OpenAsync(CancellationToken cancellationToken = default)
 
     private void WebSocketClientOnMessageReceived(object sender, MessageReceivedEventArgs args)
     {
-        object parsed = JsonUtilities.Parse(args.Message);
-        if (parsed is IDictionary<string, object> message)
+        try
         {
-            ProcessMessage(message);
+            object parsed = JsonUtilities.Parse(args.Message);
+            if (parsed is IDictionary<string, object> message)
+            {
+                ProcessMessage(message);
+            }
+            else
+            {
+                Debug.WriteLine($"Invalid message format received: {args.Message}");
+            }
         }
-        else
+        catch (ArgumentException ex)
         {
-            Debug.WriteLine($"Invalid message format received: {args.Message}");
+            Debug.WriteLine($"Error parsing message: {ex.Message}");
+            Error?.Invoke(this, new ParseLiveQueryErrorEventArgs(31, $"Failed to parse message: {ex.Message}", true, ex));
         }
     }
-
     /// <summary>
     /// Establishes a connection to the live query server asynchronously.
     /// </summary>
@@ -385,6 +392,7 @@ private void WebSocketClientOnMessageReceived(object sender, MessageReceivedEven
     /// </exception>
     public async Task ConnectAsync(CancellationToken cancellationToken = default)
     {
+        ThrowIfDisposed();
         if (_state == ParseLiveQueryState.Closed)
         {
             _state = ParseLiveQueryState.Connecting;
@@ -405,10 +413,9 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
                 await SendMessage(await AppendSessionToken(message), cancellationToken);
 
                 using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-                cts.CancelAfter(TimeOut);
+                cts.CancelAfter(Timeout);
 
                 await ConnectionSignal.Task.WaitAsync(cts.Token);
-                _state = ParseLiveQueryState.Connected;
             }
             catch (OperationCanceledException)
             {
@@ -458,7 +465,7 @@ private async Task SendAndWaitForSignalAsync(IDictionary<string, object> message
             await SendMessage(message, cancellationToken);
 
             using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            cts.CancelAfter(TimeOut);
+            cts.CancelAfter(Timeout);
 
             await tcs.Task.WaitAsync(cts.Token);
         }
@@ -496,6 +503,7 @@ private async Task SendAndWaitForSignalAsync(IDictionary<string, object> message
     /// </exception>
     public async Task<IParseLiveQuerySubscription> SubscribeAsync<T>(ParseLiveQuery<T> liveQuery, CancellationToken cancellationToken = default) where T : ParseObject
     {
+        ThrowIfDisposed();
         if (_state == ParseLiveQueryState.Closed)
         {
             throw new InvalidOperationException("Cannot subscribe to a live query when the connection is closed.");
@@ -535,6 +543,7 @@ public async Task<IParseLiveQuerySubscription> SubscribeAsync<T>(ParseLiveQuery<
     /// </returns>
     public async Task UpdateSubscriptionAsync<T>(ParseLiveQuery<T> liveQuery, int requestId, CancellationToken cancellationToken = default) where T : ParseObject
     {
+        ThrowIfDisposed();
         Dictionary<string, object> message = new Dictionary<string, object>
         {
             { "op", "update" },
@@ -561,6 +570,7 @@ public async Task UpdateSubscriptionAsync<T>(ParseLiveQuery<T> liveQuery, int re
     /// </exception>
     public async Task UnsubscribeAsync(int requestId, CancellationToken cancellationToken = default)
     {
+        ThrowIfDisposed();
         Dictionary<string, object> message = new Dictionary<string, object>
         {
             { "op", "unsubscribe" },
@@ -581,6 +591,7 @@ public async Task UnsubscribeAsync(int requestId, CancellationToken cancellation
     /// </returns>
     public async Task CloseAsync(CancellationToken cancellationToken = default)
     {
+        ThrowIfDisposed();
         WebSocketClient.MessageReceived -= WebSocketClientOnMessageReceived;
         WebSocketClient.WebsocketError -= WebSocketClientOnWebsocketError;
         WebSocketClient.UnknownError -= WebSocketClientOnUnknownError;
@@ -635,18 +646,17 @@ private void Dispose(bool disposing)
         if (disposing)
         {
             // For sync disposal, the best effort cleanup without waiting
-            _ = Task.Run(async () =>
+            try
+            {
+                CloseAsync().GetAwaiter().GetResult();
+            }
+            catch (Exception ex)
             {
-                try
-                {
-                    await CloseAsync();
-                }
-                catch (Exception ex)
-                {
-                    Debug.WriteLine($"Error during disposal: {ex}");
-                }
-            });
+                Debug.WriteLine($"Error during disposal: {ex}");
+            }
         }
         disposed = true;
     }
+
+    private void ThrowIfDisposed() => ObjectDisposedException.ThrowIf(disposed, nameof(ParseLiveQueryController));
 }
diff --git a/Parse/Platform/LiveQueries/ParseLiveQueryErrorEventArgs.cs b/Parse/Platform/LiveQueries/ParseLiveQueryErrorEventArgs.cs
@@ -8,7 +8,7 @@ namespace Parse.Platform.LiveQueries;
 public class ParseLiveQueryErrorEventArgs : EventArgs
 {
     /// <summary>
-    /// Gets or sets the error message associated with a live query operation.
+    /// Gets the error message associated with a live query operation.
     /// </summary>
     /// <remarks>
     /// The <see cref="Error"/> property contains a description of the error that occurred during
@@ -18,7 +18,7 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     public string Error { get; }
 
     /// <summary>
-    /// Gets or sets the error code associated with a live query operation.
+    /// Gets the error code associated with a live query operation.
     /// </summary>
     /// <remarks>
     /// The <see cref="Code"/> property contains a numerical identifier that represents
@@ -28,7 +28,7 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     public int Code { get; }
 
     /// <summary>
-    /// Gets or sets a value indicating whether the client should attempt to reconnect
+    /// Gets a value indicating whether the client should attempt to reconnect
     /// after an error occurs during a live query operation.
     /// </summary>
     /// <remarks>
@@ -50,10 +50,13 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     public Exception LocalException { get; }
 
     /// <summary>
-    /// Represents the arguments for an error event that occurs during a live query in the Parse platform.
+    /// Initializes a new instance of the <see cref="ParseLiveQueryErrorEventArgs"/> class.
     /// </summary>
-    internal ParseLiveQueryErrorEventArgs(int code, string error, bool reconnect, Exception localException = null)
-    {
+    /// <param name="code">The error code associated with the live query operation.</param>
+    /// <param name="error">The error message associated with the live query operation.</param>
+    /// <param name="reconnect">A value indicating whether the client should attempt to reconnect.</param>
+    /// <param name="localException">The local exception that occurred, if any.</param>
+    internal ParseLiveQueryErrorEventArgs(int code, string error, bool reconnect, Exception localException = null)    {
         Error = error;
         Code = code;
         Reconnect = reconnect;
diff --git a/Parse/Platform/LiveQueries/ParseLiveQueryEventArgs.cs b/Parse/Platform/LiveQueries/ParseLiveQueryEventArgs.cs
@@ -3,9 +3,7 @@
 namespace Parse.Platform.LiveQueries;
 
 /// <summary>
-/// Provides event arguments for events triggered by Parse's Live Query service.
-/// This class encapsulates details about a particular event, such as the operation type,
-/// client ID, request ID, and the associated Parse object data.
+/// Provides the data object for events triggered by Parse's Live Query service.
 /// </summary>
 public class ParseLiveQueryEventArgs : EventArgs
 {
diff --git a/Parse/Platform/LiveQueries/ParseLiveQuerySubscription.cs b/Parse/Platform/LiveQueries/ParseLiveQuerySubscription.cs
diff --git a/Parse/Platform/Queries/ParseQuery.cs b/Parse/Platform/Queries/ParseQuery.cs

Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,5 @@ public class MessageReceivedEventArgs(string message) : EventArgs`
`10`	`10`	`/// <summary>`
`11`	`11`	`/// Gets the message content that was received.`
`12`	`12`	`/// </summary>`
`13`		`- public string Message { get; } = message;`
	`13`	`+ public string Message { get; } = message ?? throw new ArgumentNullException(nameof(message));`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Parse.Infrastructure.Execution;`
`13`	`13`	`/// Represents a WebSocket client that allows connecting to a WebSocket server, sending messages, and receiving messages.`
`14`	`14`	`/// Implements the <c>IWebSocketClient</c> interface for WebSocket operations.`
`15`	`15`	`/// </summary>`
`16`		`-class TextWebSocketClient(int bufferSize) : IWebSocketClient`
	`16`	`+class TextWebSocketClient(int bufferSize) : IWebSocketClient, IDisposable`
`17`	`17`	`{`
`18`	`18`	`/// <summary>`
`19`	`19`	`/// A private instance of the ClientWebSocket class used to manage the WebSocket connection.`
`@@ -68,7 +68,7 @@ public async Task OpenAsync(string serverUri, CancellationToken cancellationToke`
`68`	`68`	`webSocketToConnect = webSocket;`
`69`	`69`	`}`
`70`	`70`	`}`
`71`		`-`
	`71`	`+ listeningCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);`
`72`	`72`	`if (webSocketToConnect is not null)`
`73`	`73`	`{`
`74`	`74`	`await webSocketToConnect.ConnectAsync(new Uri(serverUri), cancellationToken);`
`@@ -86,10 +86,7 @@ public async Task OpenAsync(string serverUri, CancellationToken cancellationToke`
`86`	`86`	`/// </returns>`
`87`	`87`	`public async Task CloseAsync(CancellationToken cancellationToken = default)`
`88`	`88`	`{`
`89`		`- if (webSocket is not null)`
`90`		`- {`
`91`		`- await webSocket?.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken)!;`
`92`		`- }`
	`89`	`+ await webSocket?.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken)!;`
`93`	`90`	`}`
`94`	`91`
`95`	`92`	`private async Task ListenForMessages(CancellationToken cancellationToken)`
`@@ -107,7 +104,6 @@ private async Task ListenForMessages(CancellationToken cancellationToken)`
`107`	`104`
`108`	`105`	`if (result.MessageType == WebSocketMessageType.Close)`
`109`	`106`	`{`
`110`		`- await CloseAsync(cancellationToken);`
`111`	`107`	`break;`
`112`	`108`	`}`
`113`	`109`
`@@ -118,17 +114,17 @@ private async Task ListenForMessages(CancellationToken cancellationToken)`
`118`	`114`	`}`
`119`	`115`	`else`
`120`	`116`	`{`
`121`		`- // Handle partial messages by accumulating data until EndOfMessage is true`
`122`		`- StringBuilder messageBuilder = new StringBuilder();`
`123`		`- messageBuilder.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));`
	`117`	`+ // Accumulate bytes to handle UTF-8 characters split across boundaries`
	`118`	`+ using var messageStream = new MemoryStream();`
	`119`	`+ messageStream.Write(buffer, 0, result.Count);`
`124`	`120`	`while (!result.EndOfMessage)`
`125`	`121`	`{`
`126`	`122`	`result = await webSocket.ReceiveAsync(`
`127`	`123`	`new ArraySegment<byte>(buffer),`
`128`	`124`	`cancellationToken);`
`129`		`- messageBuilder.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));`
	`125`	`+ messageStream.Write(buffer, 0, result.Count);`
`130`	`126`	`}`
`131`		`- string fullMessage = messageBuilder.ToString();`
	`127`	`+ string fullMessage = Encoding.UTF8.GetString(messageStream.ToArray());`
`132`	`128`	`MessageReceived?.Invoke(this, new MessageReceivedEventArgs(fullMessage));`
`133`	`129`	`}`
`134`	`130`	`}`
`@@ -206,4 +202,33 @@ public async Task SendAsync(string message, CancellationToken cancellationToken`
`206`	`202`	`}`
`207`	`203`	`await webSocket.SendAsync(Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, cancellationToken);`
`208`	`204`	`}`
	`205`	`+`
	`206`	`+ private CancellationTokenSource listeningCts;`
	`207`	`+ private bool disposed;`
	`208`	`+`
	`209`	`+ public void Dispose()`
	`210`	`+ {`
	`211`	`+ Dispose(true);`
	`212`	`+ GC.SuppressFinalize(this);`
	`213`	`+ }`
	`214`	`+`
	`215`	`+ protected virtual void Dispose(bool disposing)`
	`216`	`+ {`
	`217`	`+ if (!disposed)`
	`218`	`+ {`
	`219`	`+ if (disposing)`
	`220`	`+ {`
	`221`	`+ listeningCts?.Cancel();`
	`222`	`+ try`
	`223`	`+ {`
	`224`	`+ listeningTask?.Wait(TimeSpan.FromSeconds(5));`
	`225`	`+ }`
	`226`	`+ catch { }`
	`227`	`+`
	`228`	`+ webSocket?.Dispose();`
	`229`	`+ listeningCts?.Dispose();`
	`230`	`+ }`
	`231`	`+ disposed = true;`
	`232`	`+ }`
	`233`	`+ }`
`209`	`234`	`}`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ public IWebSocketClient WebSocketClient`
`171`	`171`
`172`	`172`	`public IParseLiveQueryController LiveQueryController`
`173`	`173`	`{`
`174`		`- get => LateInitializer.GetValue<IParseLiveQueryController>(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.TimeOut, WebSocketClient, Decoder));`
	`174`	`+ get => LateInitializer.GetValue<IParseLiveQueryController>(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.Timeout, WebSocketClient, Decoder));`
`175`	`175`	`set => LateInitializer.SetValue(value);`
`176`	`176`	`}`
`177`	`177`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public class ServiceHub : IServiceHub`
`72`	`72`	`public IParseInstallationDataFinalizer InstallationDataFinalizer => LateInitializer.GetValue(() => new ParseInstallationDataFinalizer { });`
`73`	`73`
`74`	`74`	`public IWebSocketClient WebSocketClient => LateInitializer.GetValue(() => LiveQueryServerConnectionData is null ? null : new TextWebSocketClient(LiveQueryServerConnectionData.MessageBufferSize));`
`75`		`- public IParseLiveQueryController LiveQueryController => LateInitializer.GetValue(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.TimeOut, WebSocketClient, Decoder));`
	`75`	`+ public IParseLiveQueryController LiveQueryController => LateInitializer.GetValue(() => LiveQueryServerConnectionData is null ? null : new ParseLiveQueryController(LiveQueryServerConnectionData.Timeout, WebSocketClient, Decoder));`
`76`	`76`
`77`	`77`	`public bool Reset()`
`78`	`78`	`{`