ConfigureAwait(false)

roblans · roblans · commit 6bcf7397adaf · 2020-08-09T17:53:29.000+02:00
diff --git a/src/Blu4Net/BluPlayer.cs b/src/Blu4Net/BluPlayer.cs
@@ -80,9 +80,9 @@ public static async Task<BluPlayer> Connect(Uri endpoint)
                 throw new ArgumentNullException(nameof(endpoint));
             
             var channel = new BluChannel(endpoint);
-            var syncStatus = await channel.GetSyncStatus();
-            var status = await channel.GetStatus();
-            var content = await channel.BrowseContent();
+            var syncStatus = await channel.GetSyncStatus().ConfigureAwait(false);
+            var status = await channel.GetStatus().ConfigureAwait(false);
+            var content = await channel.BrowseContent().ConfigureAwait(false);
 
             return new BluPlayer(channel, syncStatus, status, content);
         }
@@ -113,7 +113,7 @@ public TextWriter Log
 
         public async Task<int> GetVolume()
         {
-            var response = await _channel.GetVolume();
+            var response = await _channel.GetVolume().ConfigureAwait(false);
             return response.Volume;
         }
 
@@ -122,101 +122,101 @@ public async Task<int> SetVolume(int percentage)
             if (percentage < 0 || percentage > 100)
                 throw new ArgumentOutOfRangeException(nameof(percentage), "Value must be between 0 and 100");
 
-            var response = await _channel.SetVolume(percentage);
+            var response = await _channel.SetVolume(percentage).ConfigureAwait(false);
             return response.Volume;
         }
 
         public async Task<int> Mute(bool on = true)
         {
-            var response = await _channel.Mute(on ? 1 : 0);
+            var response = await _channel.Mute(on ? 1 : 0).ConfigureAwait(false);
             return response.Volume;
         }
 
         public async Task<PlayerState> GetState()
         {
-            var response = await _channel.GetStatus();
+            var response = await _channel.GetStatus().ConfigureAwait(false);
             return BluParser.ParseState(response.State);
         }
 
         public async Task<PlayerState> Play()
         {
-            var response = await _channel.Play();
+            var response = await _channel.Play().ConfigureAwait(false);
             return BluParser.ParseState(response.State);
         }
 
         public async Task<PlayerState> Seek(TimeSpan offset)
         {
-            var response = await _channel.Play((int)offset.TotalSeconds);
+            var response = await _channel.Play((int)offset.TotalSeconds).ConfigureAwait(false);
             return BluParser.ParseState(response.State);
         }
 
         public async Task<PlayerState> Pause(bool toggle = false)
         {
-            var response = await _channel.Pause(toggle ? 1 : 0);
+            var response = await _channel.Pause(toggle ? 1 : 0).ConfigureAwait(false);
             return BluParser.ParseState(response.State);
         }
 
         public async Task<PlayerState> Stop()
         {
-            var response = await _channel.Stop();
+            var response = await _channel.Stop().ConfigureAwait(false);
             return BluParser.ParseState(response.State);
         }
 
         public async Task<int?> Back()
         {
-            var status = await _channel.GetStatus();
+            var status = await _channel.GetStatus().ConfigureAwait(false);
             if (status.StreamUrl == null)
             { 
-                var response = await _channel.Back();
+                var response = await _channel.Back().ConfigureAwait(false);
                 return response?.ID;
             }
             return null;
         }
 
         public async Task<int?> Skip()
         {
-            var status = await _channel.GetStatus();
+            var status = await _channel.GetStatus().ConfigureAwait(false);
             if (status.StreamUrl == null)
             {
-                var response = await _channel.Skip();
+                var response = await _channel.Skip().ConfigureAwait(false);
                 return response?.ID;
             }
             return null;
         }
 
         public async Task<ShuffleMode> GetShuffleMode()
         {
-            var response = await _channel.GetShuffle();
+            var response = await _channel.GetShuffle().ConfigureAwait(false);
             return (ShuffleMode)response.Shuffle;
         }
 
         public async Task<ShuffleMode> SetShuffleMode(ShuffleMode mode = ShuffleMode.ShuffleOn)
         {
-            var response = await _channel.SetShuffle((int)mode);
+            var response = await _channel.SetShuffle((int)mode).ConfigureAwait(false);
             return (ShuffleMode)response.Shuffle;
         }
 
         public async Task<RepeatMode> GetRepeatMode()
         {
-            var response = await _channel.GetRepeat();
+            var response = await _channel.GetRepeat().ConfigureAwait(false);
             return (RepeatMode)response.Repeat;
         }
 
         public async Task<RepeatMode> SetRepeatMode(RepeatMode mode = RepeatMode.RepeatAll)
         {
-            var response = await _channel.SetRepeat((int)mode);
+            var response = await _channel.SetRepeat((int)mode).ConfigureAwait(false);
             return (RepeatMode)response.Repeat;
         }
 
         public async Task<PlayerMedia> GetMedia()
         {
-            var response = await _channel.GetStatus();
+            var response = await _channel.GetStatus().ConfigureAwait(false);
             return new PlayerMedia(response, Endpoint);
         }
 
         public async Task<PlayPosition> GetPosition()
         {
-            var response = await _channel.GetStatus();
+            var response = await _channel.GetStatus().ConfigureAwait(false);
             return new PlayPosition(response);
         }
 
diff --git a/src/Blu4Net/Channel/BluChannel.cs b/src/Blu4Net/Channel/BluChannel.cs
@@ -69,8 +69,8 @@ private async Task<XDocument> SendRequest(string request, NameValueCollection pa
             {
                 client.DefaultRequestHeaders.AcceptLanguage.TryParseAdd(AcceptLanguage.Name);
 
-                using (var response = await client.GetAsync(requestUri, cancellationToken))
-                using (var stream = await response.Content.ReadAsStreamAsync())
+                using (var response = await client.GetAsync(requestUri, cancellationToken).ConfigureAwait(false))
+                using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
                 {
                     var document = XDocument.Load(stream);
 
@@ -98,7 +98,7 @@ private async Task<T> SendRequest<T>(string request, NameValueCollection paramet
             if (request == null)
                 throw new ArgumentNullException(nameof(request));
 
-            var document = await SendRequest(request, parameters, timeout, cancellationToken);
+            var document = await SendRequest(request, parameters, timeout, cancellationToken).ConfigureAwait(false);
             return document.Deserialize<T>();
         }
 
@@ -132,7 +132,7 @@ private IObservable<T> LongPolling<T>(string request, int timeout) where T : Lon
                         }
                         try
                         {
-                            var response = await SendRequest<T>(request, parameters, InfiniteTimeout, cancellationToken);
+                            var response = await SendRequest<T>(request, parameters, InfiniteTimeout, cancellationToken).ConfigureAwait(false);
 
                             if (longPollingTag != null)
                             {
@@ -159,12 +159,12 @@ private IObservable<T> LongPolling<T>(string request, int timeout) where T : Lon
 
         public async Task<StatusResponse> GetStatus()
         {
-            return await SendRequest<StatusResponse>("Status");
+            return await SendRequest<StatusResponse>("Status").ConfigureAwait(false);
         }
 
         public async Task<SyncStatusResponse> GetSyncStatus()
         {
-            return await SendRequest<SyncStatusResponse>("SyncStatus");
+            return await SendRequest<SyncStatusResponse>("SyncStatus").ConfigureAwait(false);
         }
 
         public Task<PlayResponse> Play()
@@ -193,27 +193,27 @@ public async Task<PlayResponse> Pause(int toggle = 0)
                 parameters["toggle"] = toggle.ToString();
             }
 
-            return await SendRequest<PlayResponse>("Pause", parameters);
+            return await SendRequest<PlayResponse>("Pause", parameters).ConfigureAwait(false);
         }
 
         public async Task<StopResponse> Stop()
         {
-            return await SendRequest<StopResponse>("Stop");
+            return await SendRequest<StopResponse>("Stop").ConfigureAwait(false);
         }
 
         public async Task<SkipResponse> Skip()
         {
-            return await SendRequest<SkipResponse>("Skip");
+            return await SendRequest<SkipResponse>("Skip").ConfigureAwait(false);
         }
 
         public async Task<BackResponse> Back()
         {
-            return await SendRequest<BackResponse>("Back");
+            return await SendRequest<BackResponse>("Back").ConfigureAwait(false);
         }
 
         public async Task<VolumeResponse> GetVolume()
         {
-            return await SendRequest<VolumeResponse>("Volume");
+            return await SendRequest<VolumeResponse>("Volume").ConfigureAwait(false);
         }
 
         public async Task<VolumeResponse> SetVolume(int percentage)
@@ -223,7 +223,7 @@ public async Task<VolumeResponse> SetVolume(int percentage)
 
             var parameters = HttpUtility.ParseQueryString(string.Empty);
             parameters["level"] = percentage.ToString();
-            return await SendRequest<VolumeResponse>("Volume", parameters);
+            return await SendRequest<VolumeResponse>("Volume", parameters).ConfigureAwait(false);
         }
 
         public async Task<VolumeResponse> Mute(int mute = 1)
@@ -233,14 +233,14 @@ public async Task<VolumeResponse> Mute(int mute = 1)
 
             var parameters = HttpUtility.ParseQueryString(string.Empty);
             parameters["mute"] = mute.ToString();
-            return await SendRequest<VolumeResponse>("Volume", parameters);
+            return await SendRequest<VolumeResponse>("Volume", parameters).ConfigureAwait(false);
         }
 
         public async Task<PlaylistStatusResponse> GetPlaylistStatus()
         {
             var parameters = HttpUtility.ParseQueryString(string.Empty);
             parameters["length"] = 1.ToString();
-            return await SendRequest<PlaylistStatusResponse>("Playlist", parameters);
+            return await SendRequest<PlaylistStatusResponse>("Playlist", parameters).ConfigureAwait(false);
         }
 
         private async Task<PlaylistResponse> GetPlaylist(int startIndex, int length)
@@ -257,7 +257,7 @@ private async Task<PlaylistResponse> GetPlaylist(int startIndex, int length)
                 parameters["end"] = (startIndex + length - 1).ToString();
             }
             
-            var response = await SendRequest<PlaylistResponse>("Playlist", parameters);
+            var response = await SendRequest<PlaylistResponse>("Playlist", parameters).ConfigureAwait(false);
             if (response.Songs == null)
             {
                 response.Songs = new PlaylistResponse.Song[0];
@@ -271,7 +271,7 @@ public async IAsyncEnumerable<PlaylistResponse> GetPlaylistPaged(int pageSize)
 
             while (true)
             {
-                var listing = await GetPlaylist(startIndex, pageSize);
+                var listing = await GetPlaylist(startIndex, pageSize).ConfigureAwait(false);
                 if (listing.Songs.Length == 0)
                     break;
 
@@ -287,7 +287,7 @@ public Task<PlaylistResponse> GetPlaylist()
 
         public async Task<ClearResponse> Clear()
         {
-            return await SendRequest<ClearResponse>("Clear");
+            return await SendRequest<ClearResponse>("Clear").ConfigureAwait(false);
         }
 
         public Task<DeleteResponse> Delete(int id)
@@ -341,7 +341,7 @@ public Task<RepeatResponse> SetRepeat(int state)
 
         public async Task<PresetsResponse> GetPresets()
         {
-            var response = await SendRequest<PresetsResponse>("Presets");
+            var response = await SendRequest<PresetsResponse>("Presets").ConfigureAwait(false);
             if (response.Presets == null)
             {
                 response.Presets = new PresetsResponse.Preset[0];
@@ -354,7 +354,7 @@ public async Task<PresetLoadedResponse> LoadPreset(int id)
             var parameters = HttpUtility.ParseQueryString(string.Empty);
             parameters["id"] = id.ToString();
             
-            var document = await SendRequest("Preset", parameters);
+            var document = await SendRequest("Preset", parameters).ConfigureAwait(false);
             if (document.Root.Name == "loaded")
             {
                 return document.Deserialize<PlaylistPresetLoadedResponse>();
@@ -379,7 +379,7 @@ public async Task<BrowseContentResponse> BrowseContent(string key = null, string
                 }
             }
             
-            var response = await SendRequest<BrowseContentResponse>("Browse", parameters);
+            var response = await SendRequest<BrowseContentResponse>("Browse", parameters).ConfigureAwait(false);
             if (response.Items == null)
             {
                 response.Items = new BrowseContentResponse.Item[0];
diff --git a/src/Blu4Net/MusicContentEntry.cs b/src/Blu4Net/MusicContentEntry.cs
@@ -41,7 +41,7 @@ public async Task<MusicContentNode> Resolve()
             if (_key == null)
                 throw new InvalidOperationException("This entry is not resolvable");
 
-            var response = await _channel.BrowseContent(_key);
+            var response = await _channel.BrowseContent(_key).ConfigureAwait(false);
             return new MusicContentNode(_channel, Node, response);
         }
 
diff --git a/src/Blu4Net/MusicContentNode.cs b/src/Blu4Net/MusicContentNode.cs
@@ -38,7 +38,7 @@ public async Task<MusicContentNode> Search(string searchTerm)
             if (_searchKey == null)
                 throw new NotSupportedException("Musicsource is not searchable");
 
-            var response = await _channel.BrowseContent(_searchKey, searchTerm);
+            var response = await _channel.BrowseContent(_searchKey, searchTerm).ConfigureAwait(false);
             return new MusicContentNode(_channel, this, response);
         }
 
diff --git a/src/Blu4Net/PlayQueue.cs b/src/Blu4Net/PlayQueue.cs
@@ -22,18 +22,18 @@ public PlayQueue(BluChannel channel, StatusResponse status)
             Changes = _channel.StatusChanges
             .SkipWhile(response => response.PlaylistID == status.PlaylistID)
             .DistinctUntilChanged(response => response.PlaylistID)
-            .SelectAsync(async _ => await GetInfo());
+            .SelectAsync(async _ => await GetInfo().ConfigureAwait(false));
         }
 
         public async Task<PlayQueueInfo>  GetInfo()
         {
-            var status = await _channel.GetPlaylistStatus();
+            var status = await _channel.GetPlaylistStatus().ConfigureAwait(false);
             return new PlayQueueInfo(status);
         }
 
         public async IAsyncEnumerable<IReadOnlyCollection<PlayQueueSong>> GetSongs(int pageSize)
         {
-            await foreach (var list in _channel.GetPlaylistPaged(pageSize))
+            await foreach (var list in _channel.GetPlaylistPaged(pageSize).ConfigureAwait(false))
             {
                 yield return list.Songs.Select(element => new PlayQueueSong(element)).ToArray();
             }
@@ -51,7 +51,7 @@ public Task Remove(int songID)
 
         public async Task<int> Save(string name)
         {
-            var response = await _channel.Save(name);
+            var response = await _channel.Save(name).ConfigureAwait(false);
             return response.Entries;
         }
     }
diff --git a/src/Blu4Net/PlayerPresetList.cs b/src/Blu4Net/PlayerPresetList.cs
@@ -23,13 +23,13 @@ public PlayerPresetList(BluChannel channel, StatusResponse status)
             Changes = _channel.StatusChanges
             .SkipWhile(response => response.PresetsID == status.PresetsID)
             .DistinctUntilChanged(response => response.PresetsID)
-            .SelectAsync(async _ => await GetPresets());
+            .SelectAsync(async _ => await GetPresets().ConfigureAwait(false));
         }
 
 
         public async Task<IReadOnlyCollection<PlayerPreset>> GetPresets()
         {
-            var response = await _channel.GetPresets();
+            var response = await _channel.GetPresets().ConfigureAwait(false);
             return response.Presets
                 .Select(element => new PlayerPreset(element, _channel.Endpoint))
                 .ToArray();

Original file line number	Diff line number	Diff line change
`@@ -80,9 +80,9 @@ public static async Task<BluPlayer> Connect(Uri endpoint)`
`80`	`80`	`throw new ArgumentNullException(nameof(endpoint));`
`81`	`81`
`82`	`82`	`var channel = new BluChannel(endpoint);`
`83`		`- var syncStatus = await channel.GetSyncStatus();`
`84`		`- var status = await channel.GetStatus();`
`85`		`- var content = await channel.BrowseContent();`
	`83`	`+ var syncStatus = await channel.GetSyncStatus().ConfigureAwait(false);`
	`84`	`+ var status = await channel.GetStatus().ConfigureAwait(false);`
	`85`	`+ var content = await channel.BrowseContent().ConfigureAwait(false);`
`86`	`86`
`87`	`87`	`return new BluPlayer(channel, syncStatus, status, content);`
`88`	`88`	`}`
`@@ -113,7 +113,7 @@ public TextWriter Log`
`113`	`113`
`114`	`114`	`public async Task<int> GetVolume()`
`115`	`115`	`{`
`116`		`- var response = await _channel.GetVolume();`
	`116`	`+ var response = await _channel.GetVolume().ConfigureAwait(false);`
`117`	`117`	`return response.Volume;`
`118`	`118`	`}`
`119`	`119`
`@@ -122,101 +122,101 @@ public async Task<int> SetVolume(int percentage)`
`122`	`122`	`if (percentage < 0 \|\| percentage > 100)`
`123`	`123`	`throw new ArgumentOutOfRangeException(nameof(percentage), "Value must be between 0 and 100");`
`124`	`124`
`125`		`- var response = await _channel.SetVolume(percentage);`
	`125`	`+ var response = await _channel.SetVolume(percentage).ConfigureAwait(false);`
`126`	`126`	`return response.Volume;`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`public async Task<int> Mute(bool on = true)`
`130`	`130`	`{`
`131`		`- var response = await _channel.Mute(on ? 1 : 0);`
	`131`	`+ var response = await _channel.Mute(on ? 1 : 0).ConfigureAwait(false);`
`132`	`132`	`return response.Volume;`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`public async Task<PlayerState> GetState()`
`136`	`136`	`{`
`137`		`- var response = await _channel.GetStatus();`
	`137`	`+ var response = await _channel.GetStatus().ConfigureAwait(false);`
`138`	`138`	`return BluParser.ParseState(response.State);`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`public async Task<PlayerState> Play()`
`142`	`142`	`{`
`143`		`- var response = await _channel.Play();`
	`143`	`+ var response = await _channel.Play().ConfigureAwait(false);`
`144`	`144`	`return BluParser.ParseState(response.State);`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`public async Task<PlayerState> Seek(TimeSpan offset)`
`148`	`148`	`{`
`149`		`- var response = await _channel.Play((int)offset.TotalSeconds);`
	`149`	`+ var response = await _channel.Play((int)offset.TotalSeconds).ConfigureAwait(false);`
`150`	`150`	`return BluParser.ParseState(response.State);`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`public async Task<PlayerState> Pause(bool toggle = false)`
`154`	`154`	`{`
`155`		`- var response = await _channel.Pause(toggle ? 1 : 0);`
	`155`	`+ var response = await _channel.Pause(toggle ? 1 : 0).ConfigureAwait(false);`
`156`	`156`	`return BluParser.ParseState(response.State);`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`public async Task<PlayerState> Stop()`
`160`	`160`	`{`
`161`		`- var response = await _channel.Stop();`
	`161`	`+ var response = await _channel.Stop().ConfigureAwait(false);`
`162`	`162`	`return BluParser.ParseState(response.State);`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`public async Task<int?> Back()`
`166`	`166`	`{`
`167`		`- var status = await _channel.GetStatus();`
	`167`	`+ var status = await _channel.GetStatus().ConfigureAwait(false);`
`168`	`168`	`if (status.StreamUrl == null)`
`169`	`169`	`{`
`170`		`- var response = await _channel.Back();`
	`170`	`+ var response = await _channel.Back().ConfigureAwait(false);`
`171`	`171`	`return response?.ID;`
`172`	`172`	`}`
`173`	`173`	`return null;`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`public async Task<int?> Skip()`
`177`	`177`	`{`
`178`		`- var status = await _channel.GetStatus();`
	`178`	`+ var status = await _channel.GetStatus().ConfigureAwait(false);`
`179`	`179`	`if (status.StreamUrl == null)`
`180`	`180`	`{`
`181`		`- var response = await _channel.Skip();`
	`181`	`+ var response = await _channel.Skip().ConfigureAwait(false);`
`182`	`182`	`return response?.ID;`
`183`	`183`	`}`
`184`	`184`	`return null;`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`public async Task<ShuffleMode> GetShuffleMode()`
`188`	`188`	`{`
`189`		`- var response = await _channel.GetShuffle();`
	`189`	`+ var response = await _channel.GetShuffle().ConfigureAwait(false);`
`190`	`190`	`return (ShuffleMode)response.Shuffle;`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`public async Task<ShuffleMode> SetShuffleMode(ShuffleMode mode = ShuffleMode.ShuffleOn)`
`194`	`194`	`{`
`195`		`- var response = await _channel.SetShuffle((int)mode);`
	`195`	`+ var response = await _channel.SetShuffle((int)mode).ConfigureAwait(false);`
`196`	`196`	`return (ShuffleMode)response.Shuffle;`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`public async Task<RepeatMode> GetRepeatMode()`
`200`	`200`	`{`
`201`		`- var response = await _channel.GetRepeat();`
	`201`	`+ var response = await _channel.GetRepeat().ConfigureAwait(false);`
`202`	`202`	`return (RepeatMode)response.Repeat;`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`public async Task<RepeatMode> SetRepeatMode(RepeatMode mode = RepeatMode.RepeatAll)`
`206`	`206`	`{`
`207`		`- var response = await _channel.SetRepeat((int)mode);`
	`207`	`+ var response = await _channel.SetRepeat((int)mode).ConfigureAwait(false);`
`208`	`208`	`return (RepeatMode)response.Repeat;`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`public async Task<PlayerMedia> GetMedia()`
`212`	`212`	`{`
`213`		`- var response = await _channel.GetStatus();`
	`213`	`+ var response = await _channel.GetStatus().ConfigureAwait(false);`
`214`	`214`	`return new PlayerMedia(response, Endpoint);`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`public async Task<PlayPosition> GetPosition()`
`218`	`218`	`{`
`219`		`- var response = await _channel.GetStatus();`
	`219`	`+ var response = await _channel.GetStatus().ConfigureAwait(false);`
`220`	`220`	`return new PlayPosition(response);`
`221`	`221`	`}`
`222`	`222`
Original file line number	Diff line number	Diff line change
`@@ -69,8 +69,8 @@ private async Task<XDocument> SendRequest(string request, NameValueCollection pa`
`69`	`69`	`{`
`70`	`70`	`client.DefaultRequestHeaders.AcceptLanguage.TryParseAdd(AcceptLanguage.Name);`
`71`	`71`
`72`		`- using (var response = await client.GetAsync(requestUri, cancellationToken))`
`73`		`- using (var stream = await response.Content.ReadAsStreamAsync())`
	`72`	`+ using (var response = await client.GetAsync(requestUri, cancellationToken).ConfigureAwait(false))`
	`73`	`+ using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))`
`74`	`74`	`{`
`75`	`75`	`var document = XDocument.Load(stream);`
`76`	`76`
`@@ -98,7 +98,7 @@ private async Task<T> SendRequest<T>(string request, NameValueCollection paramet`
`98`	`98`	`if (request == null)`
`99`	`99`	`throw new ArgumentNullException(nameof(request));`
`100`	`100`
`101`		`- var document = await SendRequest(request, parameters, timeout, cancellationToken);`
	`101`	`+ var document = await SendRequest(request, parameters, timeout, cancellationToken).ConfigureAwait(false);`
`102`	`102`	`return document.Deserialize<T>();`
`103`	`103`	`}`
`104`	`104`
`@@ -132,7 +132,7 @@ private IObservable<T> LongPolling<T>(string request, int timeout) where T : Lon`
`132`	`132`	`}`
`133`	`133`	`try`
`134`	`134`	`{`
`135`		`- var response = await SendRequest<T>(request, parameters, InfiniteTimeout, cancellationToken);`
	`135`	`+ var response = await SendRequest<T>(request, parameters, InfiniteTimeout, cancellationToken).ConfigureAwait(false);`
`136`	`136`
`137`	`137`	`if (longPollingTag != null)`
`138`	`138`	`{`
`@@ -159,12 +159,12 @@ private IObservable<T> LongPolling<T>(string request, int timeout) where T : Lon`
`159`	`159`
`160`	`160`	`public async Task<StatusResponse> GetStatus()`
`161`	`161`	`{`
`162`		`- return await SendRequest<StatusResponse>("Status");`
	`162`	`+ return await SendRequest<StatusResponse>("Status").ConfigureAwait(false);`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`public async Task<SyncStatusResponse> GetSyncStatus()`
`166`	`166`	`{`
`167`		`- return await SendRequest<SyncStatusResponse>("SyncStatus");`
	`167`	`+ return await SendRequest<SyncStatusResponse>("SyncStatus").ConfigureAwait(false);`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`public Task<PlayResponse> Play()`
`@@ -193,27 +193,27 @@ public async Task<PlayResponse> Pause(int toggle = 0)`
`193`	`193`	`parameters["toggle"] = toggle.ToString();`
`194`	`194`	`}`
`195`	`195`
`196`		`- return await SendRequest<PlayResponse>("Pause", parameters);`
	`196`	`+ return await SendRequest<PlayResponse>("Pause", parameters).ConfigureAwait(false);`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`public async Task<StopResponse> Stop()`
`200`	`200`	`{`
`201`		`- return await SendRequest<StopResponse>("Stop");`
	`201`	`+ return await SendRequest<StopResponse>("Stop").ConfigureAwait(false);`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`public async Task<SkipResponse> Skip()`
`205`	`205`	`{`
`206`		`- return await SendRequest<SkipResponse>("Skip");`
	`206`	`+ return await SendRequest<SkipResponse>("Skip").ConfigureAwait(false);`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`public async Task<BackResponse> Back()`
`210`	`210`	`{`
`211`		`- return await SendRequest<BackResponse>("Back");`
	`211`	`+ return await SendRequest<BackResponse>("Back").ConfigureAwait(false);`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`public async Task<VolumeResponse> GetVolume()`
`215`	`215`	`{`
`216`		`- return await SendRequest<VolumeResponse>("Volume");`
	`216`	`+ return await SendRequest<VolumeResponse>("Volume").ConfigureAwait(false);`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`public async Task<VolumeResponse> SetVolume(int percentage)`
`@@ -223,7 +223,7 @@ public async Task<VolumeResponse> SetVolume(int percentage)`
`223`	`223`
`224`	`224`	`var parameters = HttpUtility.ParseQueryString(string.Empty);`
`225`	`225`	`parameters["level"] = percentage.ToString();`
`226`		`- return await SendRequest<VolumeResponse>("Volume", parameters);`
	`226`	`+ return await SendRequest<VolumeResponse>("Volume", parameters).ConfigureAwait(false);`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`public async Task<VolumeResponse> Mute(int mute = 1)`
`@@ -233,14 +233,14 @@ public async Task<VolumeResponse> Mute(int mute = 1)`
`233`	`233`
`234`	`234`	`var parameters = HttpUtility.ParseQueryString(string.Empty);`
`235`	`235`	`parameters["mute"] = mute.ToString();`
`236`		`- return await SendRequest<VolumeResponse>("Volume", parameters);`
	`236`	`+ return await SendRequest<VolumeResponse>("Volume", parameters).ConfigureAwait(false);`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`public async Task<PlaylistStatusResponse> GetPlaylistStatus()`
`240`	`240`	`{`
`241`	`241`	`var parameters = HttpUtility.ParseQueryString(string.Empty);`
`242`	`242`	`parameters["length"] = 1.ToString();`
`243`		`- return await SendRequest<PlaylistStatusResponse>("Playlist", parameters);`
	`243`	`+ return await SendRequest<PlaylistStatusResponse>("Playlist", parameters).ConfigureAwait(false);`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`private async Task<PlaylistResponse> GetPlaylist(int startIndex, int length)`
`@@ -257,7 +257,7 @@ private async Task<PlaylistResponse> GetPlaylist(int startIndex, int length)`
`257`	`257`	`parameters["end"] = (startIndex + length - 1).ToString();`
`258`	`258`	`}`
`259`	`259`
`260`		`- var response = await SendRequest<PlaylistResponse>("Playlist", parameters);`
	`260`	`+ var response = await SendRequest<PlaylistResponse>("Playlist", parameters).ConfigureAwait(false);`
`261`	`261`	`if (response.Songs == null)`
`262`	`262`	`{`
`263`	`263`	`response.Songs = new PlaylistResponse.Song[0];`
`@@ -271,7 +271,7 @@ public async IAsyncEnumerable<PlaylistResponse> GetPlaylistPaged(int pageSize)`
`271`	`271`
`272`	`272`	`while (true)`
`273`	`273`	`{`
`274`		`- var listing = await GetPlaylist(startIndex, pageSize);`
	`274`	`+ var listing = await GetPlaylist(startIndex, pageSize).ConfigureAwait(false);`
`275`	`275`	`if (listing.Songs.Length == 0)`
`276`	`276`	`break;`
`277`	`277`
`@@ -287,7 +287,7 @@ public Task<PlaylistResponse> GetPlaylist()`
`287`	`287`
`288`	`288`	`public async Task<ClearResponse> Clear()`
`289`	`289`	`{`
`290`		`- return await SendRequest<ClearResponse>("Clear");`
	`290`	`+ return await SendRequest<ClearResponse>("Clear").ConfigureAwait(false);`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`public Task<DeleteResponse> Delete(int id)`
`@@ -341,7 +341,7 @@ public Task<RepeatResponse> SetRepeat(int state)`
`341`	`341`
`342`	`342`	`public async Task<PresetsResponse> GetPresets()`
`343`	`343`	`{`
`344`		`- var response = await SendRequest<PresetsResponse>("Presets");`
	`344`	`+ var response = await SendRequest<PresetsResponse>("Presets").ConfigureAwait(false);`
`345`	`345`	`if (response.Presets == null)`
`346`	`346`	`{`
`347`	`347`	`response.Presets = new PresetsResponse.Preset[0];`
`@@ -354,7 +354,7 @@ public async Task<PresetLoadedResponse> LoadPreset(int id)`
`354`	`354`	`var parameters = HttpUtility.ParseQueryString(string.Empty);`
`355`	`355`	`parameters["id"] = id.ToString();`
`356`	`356`
`357`		`- var document = await SendRequest("Preset", parameters);`
	`357`	`+ var document = await SendRequest("Preset", parameters).ConfigureAwait(false);`
`358`	`358`	`if (document.Root.Name == "loaded")`
`359`	`359`	`{`
`360`	`360`	`return document.Deserialize<PlaylistPresetLoadedResponse>();`
`@@ -379,7 +379,7 @@ public async Task<BrowseContentResponse> BrowseContent(string key = null, string`
`379`	`379`	`}`
`380`	`380`	`}`
`381`	`381`
`382`		`- var response = await SendRequest<BrowseContentResponse>("Browse", parameters);`
	`382`	`+ var response = await SendRequest<BrowseContentResponse>("Browse", parameters).ConfigureAwait(false);`
`383`	`383`	`if (response.Items == null)`
`384`	`384`	`{`
`385`	`385`	`response.Items = new BrowseContentResponse.Item[0];`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public async Task<MusicContentNode> Resolve()`
`41`	`41`	`if (_key == null)`
`42`	`42`	`throw new InvalidOperationException("This entry is not resolvable");`
`43`	`43`
`44`		`- var response = await _channel.BrowseContent(_key);`
	`44`	`+ var response = await _channel.BrowseContent(_key).ConfigureAwait(false);`
`45`	`45`	`return new MusicContentNode(_channel, Node, response);`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public async Task<MusicContentNode> Search(string searchTerm)`
`38`	`38`	`if (_searchKey == null)`
`39`	`39`	`throw new NotSupportedException("Musicsource is not searchable");`
`40`	`40`
`41`		`- var response = await _channel.BrowseContent(_searchKey, searchTerm);`
	`41`	`+ var response = await _channel.BrowseContent(_searchKey, searchTerm).ConfigureAwait(false);`
`42`	`42`	`return new MusicContentNode(_channel, this, response);`
`43`	`43`	`}`
`44`	`44`
Original file line number	Diff line number	Diff line change
`@@ -22,18 +22,18 @@ public PlayQueue(BluChannel channel, StatusResponse status)`
`22`	`22`	`Changes = _channel.StatusChanges`
`23`	`23`	`.SkipWhile(response => response.PlaylistID == status.PlaylistID)`
`24`	`24`	`.DistinctUntilChanged(response => response.PlaylistID)`
`25`		`- .SelectAsync(async _ => await GetInfo());`
	`25`	`+ .SelectAsync(async _ => await GetInfo().ConfigureAwait(false));`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public async Task<PlayQueueInfo> GetInfo()`
`29`	`29`	`{`
`30`		`- var status = await _channel.GetPlaylistStatus();`
	`30`	`+ var status = await _channel.GetPlaylistStatus().ConfigureAwait(false);`
`31`	`31`	`return new PlayQueueInfo(status);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public async IAsyncEnumerable<IReadOnlyCollection<PlayQueueSong>> GetSongs(int pageSize)`
`35`	`35`	`{`
`36`		`- await foreach (var list in _channel.GetPlaylistPaged(pageSize))`
	`36`	`+ await foreach (var list in _channel.GetPlaylistPaged(pageSize).ConfigureAwait(false))`
`37`	`37`	`{`
`38`	`38`	`yield return list.Songs.Select(element => new PlayQueueSong(element)).ToArray();`
`39`	`39`	`}`
`@@ -51,7 +51,7 @@ public Task Remove(int songID)`
`51`	`51`
`52`	`52`	`public async Task<int> Save(string name)`
`53`	`53`	`{`
`54`		`- var response = await _channel.Save(name);`
	`54`	`+ var response = await _channel.Save(name).ConfigureAwait(false);`
`55`	`55`	`return response.Entries;`
`56`	`56`	`}`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,13 @@ public PlayerPresetList(BluChannel channel, StatusResponse status)`
`23`	`23`	`Changes = _channel.StatusChanges`
`24`	`24`	`.SkipWhile(response => response.PresetsID == status.PresetsID)`
`25`	`25`	`.DistinctUntilChanged(response => response.PresetsID)`
`26`		`- .SelectAsync(async _ => await GetPresets());`
	`26`	`+ .SelectAsync(async _ => await GetPresets().ConfigureAwait(false));`
`27`	`27`	`}`
`28`	`28`
`29`	`29`
`30`	`30`	`public async Task<IReadOnlyCollection<PlayerPreset>> GetPresets()`
`31`	`31`	`{`
`32`		`- var response = await _channel.GetPresets();`
	`32`	`+ var response = await _channel.GetPresets().ConfigureAwait(false);`
`33`	`33`	`return response.Presets`
`34`	`34`	`.Select(element => new PlayerPreset(element, _channel.Endpoint))`
`35`	`35`	`.ToArray();`