Minor optimizations

- Add ConfigureAwait(false) to all await calls.
- Don't waste allocation of zero length array.
- Don't use async/await if not necessary (avoid state machine creation under the hood).

Author: cabauman

src/Firebase/Http/HttpClientExtensions.cs

@@ -41,7 +41,7 @@ public static async Task<IReadOnlyCollection<FirebaseObject<T>>> GetObjectCollec
 
                 if (dictionary == null)
                 {
-                    return new FirebaseObject<T>[0];
+                    return Array.Empty<FirebaseObject<T>>();
                 }
 
                 return dictionary.Select(item => new FirebaseObject<T>(item.Key, item.Value)).ToList();

src/Firebase/Offline/RealtimeDatabase.cs

@@ -293,7 +293,7 @@ private IObservable<IReadOnlyCollection<FirebaseObject<T>>> GetInitialPullObserv
             }
 
             // there is an element root, which indicates the target location is not a collection but a single element
-            return Observable.Defer(async () => Observable.Return(await query.OnceSingleAsync<T>()).Select(e => new[] { new FirebaseObject<T>(this.elementRoot, e) }));
+            return Observable.Defer(async () => Observable.Return(await query.OnceSingleAsync<T>().ConfigureAwait(false)).Select(e => new[] { new FirebaseObject<T>(this.elementRoot, e) }));
         }
 
         private IDisposable InitializeStreamingSubscription(IObserver<FirebaseEvent<T>> observer)
@@ -336,19 +336,19 @@ private async void SynchronizeThread()
                 try
                 {
                     var validEntries = this.Database.Where(e => e.Value != null);
-                    await this.PullEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Pull));
+                    await PullEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Pull)).ConfigureAwait(false);
 
                     if (this.pushChanges)
                     {
-                        await this.PushEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Put || kvp.Value.SyncOptions == SyncOptions.Patch));
+                        await PushEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Put || kvp.Value.SyncOptions == SyncOptions.Patch)).ConfigureAwait(false);
                     }
                 }
                 catch (Exception ex)
                 {
                     this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex));
                 }
 
-                await Task.Delay(this.childQuery.Client.Options.SyncPeriod);
+                await Task.Delay(childQuery.Client.Options.SyncPeriod).ConfigureAwait(false);
             }
         }
 
@@ -377,7 +377,7 @@ private async Task PushEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntr
 
                 try
                 {
-                    await Task.WhenAll(tasks).WithAggregateException();
+                    await Task.WhenAll(tasks).WithAggregateException().ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -396,7 +396,7 @@ private async Task PullEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntr
 
                 try
                 { 
-                    await Task.WhenAll(tasks).WithAggregateException();
+                    await Task.WhenAll(tasks).WithAggregateException().ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -407,13 +407,13 @@ private async Task PullEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntr
 
         private async Task ResetAfterPull(Task<T> task, string key, OfflineEntry entry)
         {
-            await task;
+            await task.ConfigureAwait(false);
             this.SetAndRaise(key, new OfflineEntry(key, task.Result, entry.Priority, SyncOptions.None), FirebaseEventSource.OnlinePull);
         }
 
         private async Task ResetSyncAfterPush(Task task, string key, T obj)
         {
-            await this.ResetSyncAfterPush(task, key);
+            await ResetSyncAfterPush(task, key).ConfigureAwait(false);
 
             if (this.streamingOptions == StreamingOptions.None)
             {
@@ -423,7 +423,7 @@ private async Task ResetSyncAfterPush(Task task, string key, T obj)
 
         private async Task ResetSyncAfterPush(Task task, string key)
         {
-            await task;
+            await task.ConfigureAwait(false);
             this.ResetSyncOptions(key);
         }
 

src/Firebase/Offline/SetHandler.cs

@@ -6,17 +6,18 @@
 
     public class SetHandler<T> : ISetHandler<T>
     {
-        public virtual async Task SetAsync(ChildQuery query, string key, OfflineEntry entry)
+        public virtual Task SetAsync(ChildQuery query, string key, OfflineEntry entry)
         {
             using (var child = query.Child(key))
             {
                 if (entry.SyncOptions == SyncOptions.Put)
                 {
-                    await child.PutAsync(entry.Data);
+                    return child.PutAsync(entry.Data);
                 }
                 else
                 {
-                    await child.PatchAsync(entry.Data);
+                    
+                    return child.PatchAsync(entry.Data);
                 }
             }
         }

src/Firebase/Query/FirebaseQuery.cs

@@ -172,11 +172,11 @@ public async Task<FirebaseObject<string>> PostAsync(string data, bool generateKe
         /// <param name="timeout"> Optional timeout value. </param>
         /// <typeparam name="T"> Type of <see cref="obj"/> </typeparam>
         /// <returns> The <see cref="Task"/>. </returns>
-        public async Task PatchAsync(string data, TimeSpan? timeout = null)
+        public Task PatchAsync(string data, TimeSpan? timeout = null)
         {
             var c = this.GetClient(timeout);
 
-            await this.Silent().SendAsync(c, data, new HttpMethod("PATCH")).ConfigureAwait(false);
+            return this.Silent().SendAsync(c, data, new HttpMethod("PATCH"));
         }
 
         /// <summary>
@@ -186,11 +186,11 @@ public async Task PatchAsync(string data, TimeSpan? timeout = null)
         /// <param name="timeout"> Optional timeout value. </param>
         /// <typeparam name="T"> Type of <see cref="obj"/> </typeparam>
         /// <returns> The <see cref="Task"/>. </returns>
-        public async Task PutAsync(string data, TimeSpan? timeout = null)
+        public Task PutAsync(string data, TimeSpan? timeout = null)
         {
             var c = this.GetClient(timeout);
 
-            await this.Silent().SendAsync(c, data, HttpMethod.Put).ConfigureAwait(false);
+            return this.Silent().SendAsync(c, data, HttpMethod.Put);
         }
 
         /// <summary>

src/Firebase/Query/QueryExtensions.cs

@@ -219,7 +219,7 @@ public static Task PatchAsync<T>(this FirebaseQuery query, T obj)
 
         public static async Task<FirebaseObject<T>> PostAsync<T>(this FirebaseQuery query, T obj, bool generateKeyOffline = true)
         {
-            var result = await query.PostAsync(JsonConvert.SerializeObject(obj, query.Client.Options.JsonSerializerSettings), generateKeyOffline);
+            var result = await query.PostAsync(JsonConvert.SerializeObject(obj, query.Client.Options.JsonSerializerSettings), generateKeyOffline).ConfigureAwait(false);
 
             return new FirebaseObject<T>(result.Key, obj);
         }
@@ -231,7 +231,7 @@ public static async Task<FirebaseObject<T>> PostAsync<T>(this FirebaseQuery quer
         /// <param name="query"> Current node. </param>
         /// <param name="item"> Object to fan out. </param>
         /// <param name="relativePaths"> Locations where to store the item. </param>
-        public static async Task FanOut<T>(this ChildQuery child, T item, params string[] relativePaths)
+        public static Task FanOut<T>(this ChildQuery child, T item, params string[] relativePaths)
         {
             if (relativePaths == null)
             {
@@ -245,7 +245,7 @@ public static async Task FanOut<T>(this ChildQuery child, T item, params string[
                 fanoutObject.Add(path, item);
             }
 
-            await child.PatchAsync(fanoutObject);
+            return child.PatchAsync(fanoutObject);
         }
     }
 }