Code quality

Author: theSlyest

Parse/Abstractions/Platform/LiveQueries/IParseLiveQuerySubscription.cs

@@ -17,33 +17,33 @@ public interface IParseLiveQuerySubscription
     /// Represents the Create event for a live query subscription.
     /// This event is triggered when a new object matching the subscription's query is created.
     /// </summary>
-    public event EventHandler<ParseLiveQueryEventArgs> Create;
+    event EventHandler<ParseLiveQueryEventArgs> Create;
 
     /// <summary>
     /// Represents the Enter event for a live query subscription.
     /// This event is triggered when an object that did not previously match the query (and was thus not part of the subscription)
     /// starts matching the query, typically due to an update.
     /// </summary>
-    public event EventHandler<ParseLiveQueryDualEventArgs> Enter;
+    event EventHandler<ParseLiveQueryDualEventArgs> Enter;
 
     /// <summary>
     /// Represents the Update event for a live query subscription.
     /// This event is triggered when an existing object matching the subscription's query is updated.
     /// </summary>
-    public event EventHandler<ParseLiveQueryDualEventArgs> Update;
+    event EventHandler<ParseLiveQueryDualEventArgs> Update;
 
     /// <summary>
     /// Represents the Leave event for a live query subscription.
     /// This event is triggered when an object that previously matched the subscription's query
     /// no longer matches the criteria and is removed.
     /// </summary>
-    public event EventHandler<ParseLiveQueryDualEventArgs> Leave;
+    event EventHandler<ParseLiveQueryDualEventArgs> Leave;
 
     /// <summary>
     /// Represents the Delete event for a live query subscription.
     /// This event is triggered when an object matching the subscription's query is deleted.
     /// </summary>
-    public event EventHandler<ParseLiveQueryEventArgs> Delete;
+    event EventHandler<ParseLiveQueryEventArgs> Delete;
 
     /// <summary>
     /// Updates the current live query subscription with new query parameters,

Parse/Infrastructure/Execution/TextWebSocketClient.cs

@@ -21,7 +21,7 @@ class TextWebSocketClient : IWebSocketClient
     /// when establishing a connection and is used internally for operations such as sending messages
     /// and listening for incoming data.
     /// </summary>
-    private ClientWebSocket _webSocket;
+    private ClientWebSocket webSocket;
 
     /// <summary>
     /// A private instance of the Task class representing the background operation
@@ -31,7 +31,7 @@ class TextWebSocketClient : IWebSocketClient
     /// It is initialized when the listening process starts and monitored to prevent
     /// multiple concurrent listeners from being created.
     /// </summary>
-    private Task _listeningTask;
+    private Task listeningTask;
 
     /// <summary>
     /// An event triggered whenever a message is received from the WebSocket server.
@@ -52,11 +52,11 @@ class TextWebSocketClient : IWebSocketClient
     /// </returns>
     public async Task OpenAsync(string serverUri, CancellationToken cancellationToken = default)
     {
-        _webSocket ??= new ClientWebSocket();
+        webSocket ??= new ClientWebSocket();
 
-        if (_webSocket.State != WebSocketState.Open && _webSocket.State != WebSocketState.Connecting)
+        if (webSocket.State != WebSocketState.Open && webSocket.State != WebSocketState.Connecting)
         {
-            await _webSocket.ConnectAsync(new Uri(serverUri), cancellationToken);
+            await webSocket.ConnectAsync(new Uri(serverUri), cancellationToken);
             StartListening(cancellationToken);
         }
     }
@@ -69,8 +69,8 @@ public async Task OpenAsync(string serverUri, CancellationToken cancellationToke
     /// <returns>
     /// A task representing the asynchronous operation of closing the WebSocket connection.
     /// </returns>
-    public async Task CloseAsync(CancellationToken cancellationToken = default)
-        => await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken);
+    public async Task CloseAsync(CancellationToken cancellationToken = default) =>
+        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken);
 
     private async Task ListenForMessages(CancellationToken cancellationToken)
     {
@@ -79,9 +79,9 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
         try
         {
             while (!cancellationToken.IsCancellationRequested &&
-                   _webSocket.State == WebSocketState.Open)
+                   webSocket.State == WebSocketState.Open)
             {
-                WebSocketReceiveResult result = await _webSocket.ReceiveAsync(
+                WebSocketReceiveResult result = await webSocket.ReceiveAsync(
                     new ArraySegment<byte>(buffer),
                     cancellationToken);
 
@@ -102,21 +102,20 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
         }
     }
 
-
     /// <summary>
     /// Starts listening for incoming messages from the WebSocket connection. This method ensures that only one listener task is running at a time.
     /// </summary>
     /// <param name="cancellationToken">A cancellation token to signal the listener task to stop.</param>
     private void StartListening(CancellationToken cancellationToken)
     {
         // Make sure we don't start multiple listeners
-        if (_listeningTask is { IsCompleted: false })
+        if (listeningTask is { IsCompleted: false })
         {
             return;
         }
 
         // Start the listener task
-        _listeningTask = Task.Run(async () =>
+        listeningTask = Task.Run(async () =>
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -138,9 +137,9 @@ private void StartListening(CancellationToken cancellationToken)
     /// </returns>
     public async Task SendAsync(string message, CancellationToken cancellationToken = default)
     {
-        if (_webSocket is not null && _webSocket.State == WebSocketState.Open)
+        if (webSocket is not null && webSocket.State == WebSocketState.Open)
         {
-            await _webSocket.SendAsync(Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, cancellationToken);
+            await webSocket.SendAsync(Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, cancellationToken);
         }
     }
 }

Parse/Platform/LiveQueries/ParseLiveQuery.cs

@@ -6,18 +6,17 @@
 using System.Threading.Tasks;
 using Parse.Abstractions.Infrastructure;
 using Parse.Abstractions.Platform.LiveQueries;
-using Parse.Infrastructure.Data;
-using Parse.Infrastructure.Utilities;
 
 namespace Parse;
 
 /// <summary>
-/// The ParseLiveQuery class allows subscribing to a Query.
+/// The ParseLiveQuery class provides functionality to create and manage real-time queries on the Parse Server.
+/// It allows tracking changes on objects of a specified class that match query constraints, such as filters
+/// and watched fields, delivering updates in real-time as changes occur.
 /// </summary>
-/// <typeparam name="T"></typeparam>
+/// <typeparam name="T">Represents the type of ParseObject that this query operates on. T must inherit from ParseObject.</typeparam>
 public class ParseLiveQuery<T> where T : ParseObject
 {
-
     /// <summary>
     /// Serialized <see langword="where"/> clauses.
     /// </summary>
@@ -37,8 +36,6 @@ public class ParseLiveQuery<T> where T : ParseObject
 
     internal IServiceHub Services { get; }
 
-    private int RequestId = 0;
-
     public ParseLiveQuery(IServiceHub serviceHub, string className, IDictionary<string, object> filters, IEnumerable<string> selectedKeys = null, IEnumerable<string> watchedKeys = null)
     {
         Services = serviceHub;
@@ -61,7 +58,7 @@ public ParseLiveQuery(IServiceHub serviceHub, string className, IDictionary<stri
     /// but the remaining values can be null if they aren't changed in this
     /// composition.
     /// </summary>
-    internal ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKeys = null, Func<IDictionary<string, object>> onCreate = null)
+    private ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKeys = null)
     {
         if (source == null)
         {
@@ -74,13 +71,13 @@ internal ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKey
         KeySelections = source.KeySelections;
         KeyWatchers = source.KeyWatchers;
 
-        if (watchedKeys is { })
+        if (watchedKeys is not null)
         {
             KeyWatchers = new ReadOnlyCollection<string>(MergeWatchers(watchedKeys).ToList());
         }
     }
 
-    HashSet<string> MergeWatchers(IEnumerable<string> keys) => new((KeyWatchers ?? Enumerable.Empty<string>()).Concat(keys));
+    private HashSet<string> MergeWatchers(IEnumerable<string> keys) => [..(KeyWatchers ?? Enumerable.Empty<string>()).Concat(keys)];
 
     /// <summary>
     /// Add the provided key to the watched fields of returned ParseObjects.
@@ -93,9 +90,7 @@ internal ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKey
 
     internal IDictionary<string, object> BuildParameters()
     {
-        Dictionary<string, object> result = new Dictionary<string, object>();
-        result["className"] = ClassName;
-        result["where"] = Filters;
+        Dictionary<string, object> result = new Dictionary<string, object> { ["className"] = ClassName, ["where"] = Filters };
         if (KeySelections != null)
             result["keys"] = KeySelections.ToArray();
         if (KeyWatchers != null)
@@ -111,8 +106,6 @@ internal IDictionary<string, object> BuildParameters()
     /// A task representing the asynchronous subscription operation. Upon completion
     /// of the task, the subscription is successfully registered.
     /// </returns>
-    public async Task<IParseLiveQuerySubscription> SubscribeAsync()
-    {
-        return await Services.LiveQueryController.SubscribeAsync(this, CancellationToken.None);
-    }
+    public async Task<IParseLiveQuerySubscription> SubscribeAsync() =>
+        await Services.LiveQueryController.SubscribeAsync(this, CancellationToken.None);
 }

Parse/Platform/LiveQueries/ParseLiveQueryClient.cs

@@ -95,9 +95,9 @@ public enum ParseLiveQueryState
     public ParseLiveQueryState State { get; private set; }
 
     CancellationTokenSource ConnectionSignal { get; set; }
-    private IDictionary<int, CancellationTokenSource> SubscriptionSignals { get; } = new Dictionary<int, CancellationTokenSource> { };
-    private IDictionary<int, CancellationTokenSource> UnsubscriptionSignals { get; } = new Dictionary<int, CancellationTokenSource> { };
-    private IDictionary<int, IParseLiveQuerySubscription> Subscriptions { get; set; } = new Dictionary<int, IParseLiveQuerySubscription> { };
+    private Dictionary<int, CancellationTokenSource> SubscriptionSignals { get; } = new Dictionary<int, CancellationTokenSource> { };
+    private Dictionary<int, CancellationTokenSource> UnsubscriptionSignals { get; } = new Dictionary<int, CancellationTokenSource> { };
+    private Dictionary<int, IParseLiveQuerySubscription> Subscriptions { get; set; } = new Dictionary<int, IParseLiveQuerySubscription> { };
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ParseLiveQueryController"/> class.
@@ -243,10 +243,8 @@ private async Task<IDictionary<string, object>> AppendSessionToken(IDictionary<s
             }).ToDictionary();
     }
 
-    private async Task SendMessage(IDictionary<string, object> message, CancellationToken cancellationToken)
-    {
+    private async Task SendMessage(IDictionary<string, object> message, CancellationToken cancellationToken) =>
         await WebSocketClient.SendAsync(JsonUtilities.Encode(message), cancellationToken);
-    }
 
     private async Task OpenAsync(CancellationToken cancellationToken = default)
     {
@@ -263,8 +261,8 @@ private async Task OpenAsync(CancellationToken cancellationToken = default)
         await WebSocketClient.OpenAsync(ParseClient.Instance.Services.LiveQueryServerConnectionData.ServerURI, cancellationToken);
     }
 
-    private void WebSocketClientOnMessageReceived(object sender, string e)
-        => ProcessMessage(JsonUtilities.Parse(e) as IDictionary<string, object>);
+    private void WebSocketClientOnMessageReceived(object sender, string e) =>
+        ProcessMessage(JsonUtilities.Parse(e) as IDictionary<string, object>);
 
     /// <summary>
     /// Initiates a connection to the live query server asynchronously.
@@ -355,13 +353,13 @@ public async Task<IParseLiveQuerySubscription> SubscribeAsync<T>(ParseLiveQuery<
         bool signalReceived = completionSignal.Token.WaitHandle.WaitOne(TimeOut);
         SubscriptionSignals.Remove(requestId);
         completionSignal.Dispose();
-        if (signalReceived)
+        if (!signalReceived)
         {
-            ParseLiveQuerySubscription<T> subscription = new ParseLiveQuerySubscription<T>(liveQuery.Services, liveQuery.ClassName, requestId);
-            Subscriptions.Add(requestId, subscription);
-            return subscription;
+            throw new TimeoutException();
         }
-        throw new TimeoutException();
+        ParseLiveQuerySubscription<T> subscription = new ParseLiveQuerySubscription<T>(liveQuery.Services, liveQuery.ClassName, requestId);
+        Subscriptions.Add(requestId, subscription);
+        return subscription;
     }
 
     /// <summary>

Parse/Platform/LiveQueries/ParseLiveQueryController.cs

@@ -68,17 +68,15 @@ public ParseLiveQuerySubscription(IServiceHub serviceHub, string className, int
     /// This allows adjustments to the filter or watched keys without unsubscribing
     /// and re-subscribing.
     /// </summary>
-    /// <typeparam name="T">The type of the ParseObject associated with the subscription.</typeparam>
+    /// <typeparam name="T1">The type of the ParseObject associated with the subscription.</typeparam>
     /// <param name="liveQuery">The updated live query containing new parameters that
     /// will replace the existing ones for this subscription.</param>
     /// <param name="cancellationToken">A token to monitor for cancellation requests. If triggered,
     /// the update process will be halted.</param>
     /// <returns>A task that represents the asynchronous operation of updating
     /// the subscription with the new query parameters.</returns>
-    public async Task UpdateAsync<T>(ParseLiveQuery<T> liveQuery, CancellationToken cancellationToken = default) where T : ParseObject
-    {
+    public async Task UpdateAsync<T1>(ParseLiveQuery<T1> liveQuery, CancellationToken cancellationToken = default) where T1 : ParseObject =>
         await Services.LiveQueryController.UpdateSubscriptionAsync(liveQuery, RequestId, CancellationToken.None);
-    }
 
     /// <summary>
     /// Cancels the current live query subscription by unsubscribing from the Parse Live Query server.
@@ -87,10 +85,8 @@ public async Task UpdateAsync<T>(ParseLiveQuery<T> liveQuery, CancellationToken
     /// </summary>
     /// <param name="cancellationToken">A token to monitor for cancellation requests. If triggered, the cancellation process will halt.</param>
     /// <returns>A task that represents the asynchronous operation of canceling the subscription.</returns>
-    public async Task CancelAsync(CancellationToken cancellationToken = default)
-    {
+    public async Task CancelAsync(CancellationToken cancellationToken = default) =>
         await Services.LiveQueryController.UnsubscribeAsync(RequestId, CancellationToken.None);
-    }
 
     /// <summary>
     /// Handles the creation event for an object that matches the subscription's query.
@@ -99,36 +95,30 @@ public async Task CancelAsync(CancellationToken cancellationToken = default)
     /// <param name="objectState">
     /// The state of the object that triggered the creation event, containing its data and metadata.
     /// </param>
-    public void OnCreate(IObjectState objectState)
-    {
+    public void OnCreate(IObjectState objectState) =>
         Create?.Invoke(this, new ParseLiveQueryEventArgs(Services.GenerateObjectFromState<T>(objectState, ClassName)));
-    }
 
     /// <summary>
     /// Handles the event when an object enters the result set of a live query subscription. This occurs when an
     /// object begins to satisfy the query conditions.
     /// </summary>
     /// <param name="objectState">The current state of the object that has entered the query result set.</param>
     /// <param name="originalState">The original state of the object before entering the query result set.</param>
-    public void OnEnter(IObjectState objectState, IObjectState originalState)
-    {
+    public void OnEnter(IObjectState objectState, IObjectState originalState) =>
         Enter?.Invoke(this, new ParseLiveQueryDualEventArgs(
             Services.GenerateObjectFromState<T>(objectState, ClassName),
             Services.GenerateObjectFromState<T>(originalState, ClassName)));
-    }
 
     /// <summary>
     /// Handles the update event for objects subscribed to the Live Query. This method triggers the Update
     /// event, providing the updated object and its original state.
     /// </summary>
     /// <param name="objectState">The new state of the object after the update.</param>
     /// <param name="originalState">The original state of the object before the update.</param>
-    public void OnUpdate(IObjectState objectState, IObjectState originalState)
-    {
+    public void OnUpdate(IObjectState objectState, IObjectState originalState) =>
         Update?.Invoke(this, new ParseLiveQueryDualEventArgs(
             Services.GenerateObjectFromState<T>(objectState, ClassName),
             Services.GenerateObjectFromState<T>(originalState, ClassName)));
-    }
 
     /// <summary>
     /// Handles the event when an object leaves the result set of the live query subscription.
@@ -137,21 +127,17 @@ public void OnUpdate(IObjectState objectState, IObjectState originalState)
     /// </summary>
     /// <param name="objectState">The state of the object that left the result set.</param>
     /// <param name="originalState">The original state of the object before it left the result set.</param>
-    public void OnLeave(IObjectState objectState, IObjectState originalState)
-    {
+    public void OnLeave(IObjectState objectState, IObjectState originalState) =>
         Leave?.Invoke(this, new ParseLiveQueryDualEventArgs(
             Services.GenerateObjectFromState<T>(objectState, ClassName),
             Services.GenerateObjectFromState<T>(originalState, ClassName)));
-    }
 
     /// <summary>
     /// Handles the "delete" event for a live query subscription, triggered when an object is removed
     /// from the query's result set. This method processes the event by invoking the associated
     /// delete event handler, if subscribed, with the relevant object data.
     /// </summary>
     /// <param name="objectState">The state information of the object that was deleted.</param>
-    public void OnDelete(IObjectState objectState)
-    {
+    public void OnDelete(IObjectState objectState) =>
         Delete?.Invoke(this, new ParseLiveQueryEventArgs(Services.GenerateObjectFromState<T>(objectState, ClassName)));
-    }
 }